comment

Signed-off-by: Roger Wang <hey@rogerw.io>

.buildkite/bootstrap-amd-omni.sh

@@ -1,238 +0,0 @@
-#!/bin/bash
-# vllm-omni customized version
-# Based on: https://github.com/vllm-project/ci-infra/blob/main/buildkite/bootstrap-amd.sh
-# Last synced: 2025-12-15
-# Modifications: Use local template file instead of downloading from ci-infra
-
-set -euo pipefail
-
-if [[ -z "${RUN_ALL:-}" ]]; then
-    RUN_ALL=0
-fi
-
-if [[ -z "${NIGHTLY:-}" ]]; then
-    NIGHTLY=0
-fi
-
-if [[ -z "${VLLM_CI_BRANCH:-}" ]]; then
-    VLLM_CI_BRANCH="main"
-fi
-
-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
-    if [ "$BUILDKITE_PULL_REQUEST" != "false" ]; then
-        PR_LABELS=$(curl -s "https://api.github.com/repos/vllm-project/vllm-omni/pulls/$BUILDKITE_PULL_REQUEST" | jq -r '.labels[].name')
-        if [[ $PR_LABELS == *"$DISABLE_LABEL"* ]]; then
-            echo false
-        else
-            echo true
-        fi
-    else
-        echo false  # not a PR or BUILDKITE_PULL_REQUEST not set
-    fi
-}
-
-check_run_all_label() {
-    RUN_ALL_LABEL="ready-run-all-tests"
-    # If BUILDKITE_PULL_REQUEST != "false", then we check the PR labels using curl and jq
-    if [ "$BUILDKITE_PULL_REQUEST" != "false" ]; then
-        PR_LABELS=$(curl -s "https://api.github.com/repos/vllm-project/vllm-omni/pulls/$BUILDKITE_PULL_REQUEST" | jq -r '.labels[].name')
-        if [[ $PR_LABELS == *"$RUN_ALL_LABEL"* ]]; then
-            echo true
-        else
-            echo false
-        fi
-    else
-        echo false  # not a PR or BUILDKITE_PULL_REQUEST not set
-    fi
-}
-
-if [[ -z "${COV_ENABLED:-}" ]]; then
-    COV_ENABLED=0
-fi
-
-upload_pipeline() {
-    echo "Uploading pipeline..."
-    # Install minijinja
-    ls .buildkite || buildkite-agent annotate --style error 'Please merge upstream main branch for buildkite CI'
-    curl -sSfL https://github.com/mitsuhiko/minijinja/releases/download/2.3.1/minijinja-cli-installer.sh | sh
-    source /var/lib/buildkite-agent/.cargo/env
-
-    if [[ $BUILDKITE_PIPELINE_SLUG == "fastcheck" ]]; then
-        AMD_MIRROR_HW="amdtentative"
-    fi
-
-    # Use local template file for vllm-omni
-    cp .buildkite/test-template-amd-omni.j2 .buildkite/test-template.j2
-
-
-    # (WIP) Use pipeline generator instead of jinja template
-    if [ -e ".buildkite/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
-        exit 0
-    fi
-    echo "List file diff: $LIST_FILE_DIFF"
-    echo "Run all: $RUN_ALL"
-    echo "Nightly: $NIGHTLY"
-    echo "AMD Mirror HW: $AMD_MIRROR_HW"
-
-    FAIL_FAST=$(fail_fast)
-
-    cd .buildkite
-    (
-        set -x
-        # Output pipeline.yaml with all blank lines removed
-        minijinja-cli test-template.j2 test-amd.yaml \
-            -D branch="$BUILDKITE_BRANCH" \
-            -D list_file_diff="$LIST_FILE_DIFF" \
-            -D run_all="$RUN_ALL" \
-            -D nightly="$NIGHTLY" \
-            -D mirror_hw="$AMD_MIRROR_HW" \
-            -D fail_fast="$FAIL_FAST" \
-            -D vllm_use_precompiled="$VLLM_USE_PRECOMPILED" \
-            -D vllm_merge_base_commit="$(git merge-base origin/main HEAD)" \
-            -D cov_enabled="$COV_ENABLED" \
-            -D vllm_ci_branch="$VLLM_CI_BRANCH" \
-            | sed '/^[[:space:]]*$/d' \
-            > pipeline.yaml
-    )
-    cat pipeline.yaml
-    buildkite-agent artifact upload pipeline.yaml
-    buildkite-agent pipeline upload pipeline.yaml
-    exit 0
-}
-
-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 start: skip pipeline if conditions are met
-# ----------------------------------------------------------------------
-
-# skip pipeline if all changed files are under docs/
-if [[ "${DOCS_ONLY_DISABLE}" != "1" ]]; then
-  if [[ -n "${file_diff:-}" ]]; then
-    docs_only=1
-    # Robust iteration over newline-separated file_diff
-    while IFS= read -r f; do
-      [[ -z "$f" ]] && continue
-      # **Policy:** only skip if *every* path starts with docs/
-      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 changes detected
-
-\`\`\`
-${file_diff}
-\`\`\`" --style "info" || true
-      echo "[docs-only] All changes are under docs/. Exiting before pipeline upload."
-      exit 0
-    fi
-  fi
-fi
-
-# ----------------------------------------------------------------------
-# Early exit end
-# ----------------------------------------------------------------------
-
-patterns=(
-    "docker/Dockerfile"
-    "CMakeLists.txt"
-    "requirements/common.txt"
-    "requirements/cuda.txt"
-    "requirements/build.txt"
-    "requirements/test.txt"
-    "setup.py"
-    "csrc/"
-    "cmake/"
-)
-
-ignore_patterns=(
-    "docker/Dockerfile."
-    "csrc/cpu"
-    "csrc/rocm"
-    "cmake/hipify.py"
-    "cmake/cpu_extension.cmake"
-)
-
-for file in $file_diff; do
-    # First check if file matches any pattern
-    matches_pattern=0
-    for pattern in "${patterns[@]}"; do
-        if [[ $file == $pattern* ]] || [[ $file == $pattern ]]; then
-            matches_pattern=1
-            break
-        fi
-    done
-
-    # If file matches pattern, check it's not in ignore patterns
-    if [[ $matches_pattern -eq 1 ]]; then
-        matches_ignore=0
-        for ignore in "${ignore_patterns[@]}"; do
-            if [[ $file == $ignore* ]] || [[ $file == $ignore ]]; then
-                matches_ignore=1
-                break
-            fi
-        done
-
-        if [[ $matches_ignore -eq 0 ]]; then
-            RUN_ALL=1
-            echo "Found changes: $file. Run all tests"
-            break
-        fi
-    fi
-done
-
-# Check for ready-run-all-tests label
-LABEL_RUN_ALL=$(check_run_all_label)
-if [[ $LABEL_RUN_ALL == true ]]; then
-    RUN_ALL=1
-    NIGHTLY=1
-    echo "Found 'ready-run-all-tests' label. Running all tests including optional tests."
-fi
-
-# Decide whether to use precompiled wheels
-# Relies on existing patterns array as a basis.
-if [[ -n "${VLLM_USE_PRECOMPILED:-}" ]]; then
-    echo "VLLM_USE_PRECOMPILED is already set to: $VLLM_USE_PRECOMPILED"
-elif [[ $RUN_ALL -eq 1 ]]; then
-    export VLLM_USE_PRECOMPILED=0
-    echo "Detected critical changes, building wheels from source"
-else
-    export VLLM_USE_PRECOMPILED=1
-    echo "No critical changes, using precompiled wheels"
-fi
-
-
-LIST_FILE_DIFF=$(get_diff | tr ' ' '|')
-if [[ $BUILDKITE_BRANCH == "main" ]]; then
-    LIST_FILE_DIFF=$(get_diff_main | tr ' ' '|')
-fi
-upload_pipeline

.buildkite/pipeline.yml

@@ -7,80 +7,19 @@ steps:
       - "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"
-
-  # - label: "Test on NPU"
-  #   depends_on: ~
-  #   key: npu-test
-  #   commands:
-  #     - ".buildkite/scripts/hardware_ci/run_npu_test.sh"
-  #   agents:
-  #     queue: "ascend"
+      queue: "cpu_queue_premerge_us_east_1"
 
   - label: "Simple Unit Test"
-    depends_on: ~
     commands:
       - ".buildkite/scripts/simple_test.sh"
     agents:
       queue: "cpu_queue_premerge"
 
   - label: "Diffusion Model Test"
-    timeout_in_minutes: 20
-    depends_on: image-build
-    commands:
-      - pytest -s -v tests/e2e/offline_inference/test_t2i_model.py
-      - pytest -s -v tests/e2e/offline_inference/test_ovis_image.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"
-          volumes:
-            - "/fsx/hf_cache:/fsx/hf_cache"
-
-  - label: "Diffusion Model CPU offloading Test"
-    timeout_in_minutes: 20
-    depends_on: image-build
-    commands:
-      - pytest -s -v tests/e2e/offline_inference/test_diffusion_cpu_offload.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"
-          volumes:
-            - "/fsx/hf_cache:/fsx/hf_cache"
-
-  - label: "Audio Generation Model Test"
-    timeout_in_minutes: 20
-    depends_on: image-build
-    commands:
-      - pytest -s -v tests/e2e/offline_inference/test_stable_audio_model.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"
-          volumes:
-            - "/fsx/hf_cache:/fsx/hf_cache"
-
-  - label: "Diffusion Cache Backend Test"
     timeout_in_minutes: 15
     depends_on: image-build
     commands:
-      - pytest -s -v tests/e2e/offline_inference/test_cache_dit.py tests/e2e/offline_inference/test_teacache.py
+      - pytest -s -v tests/e2e/offline_inference/test_t2i_model.py
     agents:
       queue: "gpu_1_queue" # g6.4xlarge instance on AWS, has 1 L4 GPU
     plugins:
@@ -93,43 +32,6 @@ steps:
           volumes:
             - "/fsx/hf_cache:/fsx/hf_cache"
 
-  - label: "Diffusion Parallelism Test"
-    timeout_in_minutes: 25
-    depends_on: image-build
-    commands:
-      - pytest -s -v tests/e2e/offline_inference/test_sequence_parallel.py
-      - pytest -s -v tests/e2e/offline_inference/test_zimage_tensor_parallel.py
-    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"
-          volumes:
-            - "/fsx/hf_cache:/fsx/hf_cache"
-
-  - label: "Diffusion GPU Worker Test"
-    timeout_in_minutes: 20
-    depends_on: image-build
-    commands:
-      - pytest -s -v tests/diffusion/test_gpu_diffusion_worker.py
-    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"
-          volumes:
-            - "/fsx/hf_cache:/fsx/hf_cache"
-
   - label: "Omni Model Test"
     timeout_in_minutes: 15
     depends_on: image-build
@@ -150,11 +52,11 @@ steps:
             - "/fsx/hf_cache:/fsx/hf_cache"
 
   - label: "Omni Model Test with H100"
-    timeout_in_minutes: 30
+    timeout_in_minutes: 20
     depends_on: image-build
     commands:
       - export VLLM_WORKER_MULTIPROC_METHOD=spawn
-      - pytest -s -v tests/e2e/offline_inference/test_qwen3_omni.py tests/e2e/online_serving/test_qwen3_omni.py tests/e2e/online_serving/test_async_omni.py
+      - pytest -s -v tests/e2e/offline_inference/test_qwen3_omni.py tests/e2e/online_serving/test_qwen3_omni.py
     agents:
       queue: "mithril-h100-pool"
     plugins:
@@ -183,38 +85,3 @@ steps:
                 hostPath:
                   path: /mnt/hf-cache
                   type: DirectoryOrCreate
-
-  - label: "Diffusion Image Edit Test with H100 (1 GPU)"
-    timeout_in_minutes: 20
-    depends_on: image-build
-    commands:
-      - export VLLM_WORKER_MULTIPROC_METHOD=spawn
-      - pytest -s -v tests/e2e/online_serving/test_i2i_multi_image_input.py
-    agents:
-      queue: "mithril-h100-pool"
-    plugins:
-      - kubernetes:
-          podSpec:
-            containers:
-              - image: public.ecr.aws/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

.buildkite/scripts/docker_login_ecr_public.sh

@@ -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

.buildkite/scripts/hardware_ci/run-amd-test.sh

@@ -1,160 +0,0 @@
-#!/bin/bash
-# vllm-omni customized version
-# Based on: vllm/.buildkite/scripts/hardware_ci/run-amd-test.sh
-# Last synced: 2025-12-15
-# Modifications: docker image name for vllm-omni
-
-# This script runs test inside the corresponding ROCm docker container.
-set -o pipefail
-
-# Export Python path
-export PYTHONPATH=".."
-
-# Print ROCm version
-echo "--- Confirming Clean Initial State"
-while true; do
-        sleep 3
-        if grep -q clean /opt/amdgpu/etc/gpu_state; then
-                echo "GPUs state is \"clean\""
-                break
-        fi
-done
-
-echo "--- ROCm info"
-rocminfo
-
-# cleanup older docker images
-cleanup_docker() {
-  # Get Docker's root directory
-  docker_root=$(docker info -f '{{.DockerRootDir}}')
-  if [ -z "$docker_root" ]; then
-    echo "Failed to determine Docker root directory."
-    exit 1
-  fi
-  echo "Docker root directory: $docker_root"
-  # Check disk usage of the filesystem where Docker's root directory is located
-  disk_usage=$(df "$docker_root" | tail -1 | awk '{print $5}' | sed 's/%//')
-  # Define the threshold
-  threshold=70
-  if [ "$disk_usage" -gt "$threshold" ]; then
-    echo "Disk usage is above $threshold%. Cleaning up Docker images and volumes..."
-    # Remove dangling images (those that are not tagged and not used by any container)
-    docker image prune -f
-    # Remove unused volumes / force the system prune for old images as well.
-    docker volume prune -f && docker system prune --force --filter "until=72h" --all
-    echo "Docker images and volumes cleanup completed."
-  else
-    echo "Disk usage is below $threshold%. No cleanup needed."
-  fi
-}
-
-# Call the cleanup docker function
-cleanup_docker
-
-echo "--- Resetting GPUs"
-
-echo "reset" > /opt/amdgpu/etc/gpu_state
-
-while true; do
-        sleep 3
-        if grep -q clean /opt/amdgpu/etc/gpu_state; then
-                echo "GPUs state is \"clean\""
-                break
-        fi
-done
-
-echo "--- Pulling container"
-image_name="public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:${BUILDKITE_COMMIT}-rocm-omni"
-container_name="rocm_${BUILDKITE_COMMIT}_$(tr -dc A-Za-z0-9 < /dev/urandom | head -c 10; echo)"
-
-# 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"
-safe_docker_login_ecr_public
-# Pull the container from ECR Public Gallery
-
-docker pull "${image_name}"
-
-remove_docker_container() {
-   docker rm -f "${container_name}" || docker image rm -f "${image_name}" || true
-}
-trap remove_docker_container EXIT
-
-echo "--- Running container"
-
-HF_CACHE="$(realpath ~)/huggingface"
-mkdir -p "${HF_CACHE}"
-HF_MOUNT="/root/.cache/huggingface"
-
-commands=$@
-echo "Commands:$commands"
-
-PARALLEL_JOB_COUNT=8
-MYPYTHONPATH=".."
-
-# Test that we're launching on the machine that has
-# proper access to GPUs
-render_gid=$(getent group render | cut -d: -f3)
-if [[ -z "$render_gid" ]]; then
-  echo "Error: 'render' group not found. This is required for GPU access." >&2
-  exit 1
-fi
-
-# check if the command contains shard flag, we will run all shards in parallel because the host have 8 GPUs.
-if [[ $commands == *"--shard-id="* ]]; then
-  # assign job count as the number of shards used
-  commands=$(echo "$commands" | sed -E "s/--num-shards[[:blank:]]*=[[:blank:]]*[0-9]*/--num-shards=${PARALLEL_JOB_COUNT} /g" | sed 's/ \\ / /g')
-  for GPU in $(seq 0 $(($PARALLEL_JOB_COUNT-1))); do
-    # assign shard-id for each shard
-    commands_gpu=$(echo "$commands" | sed -E "s/--shard-id[[:blank:]]*=[[:blank:]]*[0-9]*/--shard-id=${GPU} /g" | sed 's/ \\ / /g')
-    echo "Shard ${GPU} commands:$commands_gpu"
-    echo "Render devices: $BUILDKITE_AGENT_META_DATA_RENDER_DEVICES"
-    docker run \
-        --device /dev/kfd $BUILDKITE_AGENT_META_DATA_RENDER_DEVICES \
-        --network=host \
-        --shm-size=16gb \
-        --group-add "$render_gid" \
-        --rm \
-        -e HIP_VISIBLE_DEVICES="${GPU}" \
-        -e HF_TOKEN \
-        -e AWS_ACCESS_KEY_ID \
-        -e AWS_SECRET_ACCESS_KEY \
-        -v "${HF_CACHE}:${HF_MOUNT}" \
-        -e "HF_HOME=${HF_MOUNT}" \
-        -e "PYTHONPATH=${MYPYTHONPATH}" \
-        --name "${container_name}_${GPU}" \
-        "${image_name}" \
-        /bin/bash -c "${commands_gpu}" \
-        |& while read -r line; do echo ">>Shard $GPU: $line"; done &
-    PIDS+=($!)
-  done
-  #wait for all processes to finish and collect exit codes
-  for pid in "${PIDS[@]}"; do
-    wait "${pid}"
-    STATUS+=($?)
-  done
-  for st in "${STATUS[@]}"; do
-    if [[ ${st} -ne 0 ]]; then
-      echo "One of the processes failed with $st"
-      exit "${st}"
-    fi
-  done
-else
-  echo "Render devices: $BUILDKITE_AGENT_META_DATA_RENDER_DEVICES"
-  docker run \
-          --device /dev/kfd $BUILDKITE_AGENT_META_DATA_RENDER_DEVICES \
-          --network=host \
-          --shm-size=16gb \
-          --group-add "$render_gid" \
-          --rm \
-          -e HF_TOKEN \
-          -e AWS_ACCESS_KEY_ID \
-          -e AWS_SECRET_ACCESS_KEY \
-          -v "${HF_CACHE}:${HF_MOUNT}" \
-          -e "HF_HOME=${HF_MOUNT}" \
-          -e "PYTHONPATH=${MYPYTHONPATH}" \
-          --name "${container_name}" \
-          "${image_name}" \
-          /bin/bash -c "${commands}"
-fi

.buildkite/scripts/hardware_ci/run_npu_test.sh

@@ -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.py
-'

.buildkite/scripts/simple_test.sh

@@ -47,9 +47,6 @@ fi
 VENV_PYTHON="${VENV_DIR}/bin/python"
 [[ -x "${VENV_PYTHON}" ]] || { echo "Python not found in ${VENV_DIR}"; exit 1; }
 
-"${UV_BIN}" pip install --python "${VENV_PYTHON}" vllm==0.12.0
+"${UV_BIN}" pip install --python "${VENV_PYTHON}" vllm==0.11.0
 "${UV_BIN}" pip install --python "${VENV_PYTHON}" -e ".[dev]"
-"${VENV_PYTHON}" -m pytest -v -s tests/entrypoints/
-"${VENV_PYTHON}" -m pytest -v -s tests/diffusion/cache/
-"${VENV_PYTHON}" -m pytest -v -s tests/model_executor/models/qwen2_5_omni/test_audio_length.py
-"${VENV_PYTHON}" -m pytest -v -s tests/worker/
+"${VENV_PYTHON}" -m pytest -v -s tests/test_omni_llm.py

.buildkite/test-amd.yaml

@@ -1,106 +0,0 @@
-steps:
-
-- label: "Diffusion Model Test"
-  timeout_in_minutes: 20
-  agent_pool: mi325_2
-  depends_on: amd-build
-  mirror_hardwares: [amdproduction]
-  grade: Blocking
-  commands:
-    - export GPU_ARCHS=gfx942
-    - export MIOPEN_DEBUG_CONV_DIRECT=0
-    - export MIOPEN_DEBUG_CONV_GEMM=0
-    - export VLLM_ROCM_USE_AITER=1
-    - export VLLM_ROCM_USE_AITER_MHA=1
-    - export VLLM_ROCM_USE_AITER_LINEAR=0
-    - export VLLM_ROCM_USE_AITER_RMSNORM=0
-    - pytest -s -v tests/e2e/offline_inference/test_t2i_model.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
-    - export MIOPEN_DEBUG_CONV_DIRECT=0
-    - export MIOPEN_DEBUG_CONV_GEMM=0
-    - export VLLM_ROCM_USE_AITER=1
-    - export VLLM_ROCM_USE_AITER_MHA=1
-    - export VLLM_ROCM_USE_AITER_LINEAR=0
-    - export VLLM_ROCM_USE_AITER_RMSNORM=0
-    - pytest -s -v tests/e2e/offline_inference/test_cache_dit.py tests/e2e/offline_inference/test_teacache.py
-
-- label: "Diffusion Parallelism Test"
-  timeout_in_minutes: 15
-  agent_pool: mi325_2
-  depends_on: amd-build
-  mirror_hardwares: [amdproduction]
-  grade: Blocking
-  commands:
-    - export MIOPEN_DEBUG_CONV_DIRECT=0
-    - export MIOPEN_DEBUG_CONV_GEMM=0
-    - pytest -s -v tests/e2e/offline_inference/test_sequence_parallel.py
-
-- label: "Diffusion GPU Worker Test"
-  timeout_in_minutes: 20
-  agent_pool: mi325_2
-  depends_on: amd-build
-  mirror_hardwares: [amdproduction]
-  grade: Blocking
-  commands:
-    - export MIOPEN_DEBUG_CONV_DIRECT=0
-    - export MIOPEN_DEBUG_CONV_GEMM=0
-    - pytest -s -v tests/diffusion/test_gpu_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
-    - export MIOPEN_DEBUG_CONV_DIRECT=0
-    - export MIOPEN_DEBUG_CONV_GEMM=0
-    - export VLLM_ROCM_USE_AITER=1
-    - export VLLM_ROCM_USE_AITER_MHA=1
-    - export VLLM_ROCM_USE_AITER_LINEAR=0
-    - export VLLM_ROCM_USE_AITER_RMSNORM=0
-    - pytest -s -v tests/e2e/offline_inference/test_qwen2_5_omni.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 MIOPEN_DEBUG_CONV_DIRECT=0
-    - export MIOPEN_DEBUG_CONV_GEMM=0
-    - pytest -s -v tests/e2e/offline_inference/test_qwen3_omni.py tests/e2e/online_serving/test_qwen3_omni.py
-
-- label: "Diffusion Image Edit 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
-    - export MIOPEN_DEBUG_CONV_DIRECT=0
-    - export MIOPEN_DEBUG_CONV_GEMM=0
-    - export VLLM_ROCM_USE_AITER=1
-    - export VLLM_ROCM_USE_AITER_MHA=1
-    - export VLLM_ROCM_USE_AITER_LINEAR=0
-    - export VLLM_ROCM_USE_AITER_RMSNORM=0
-    - pytest -s -v tests/e2e/online_serving/test_i2i_multi_image_input.py

.buildkite/test-template-amd-omni.j2

@@ -1,53 +0,0 @@
-{# vllm-omni customized version
-   Based on: https://github.com/vllm-project/ci-infra/blob/main/buildkite/test-template-amd.j2
-   Last synced: 2025-12-15
-   Modifications: Removed unused CUDA/NVIDIA logic, keeping only AMD tests
-#}
-{% set docker_image_amd = "public.ecr.aws/q9t5s3a7/vllm-ci-test-repo:$BUILDKITE_COMMIT-rocm-omni" %}
-{% set default_working_dir = "/app/vllm-omni" %}
-
-  - group: "AMD Tests"
-    depends_on: ~
-    steps:
-      - label: "AMD: :docker: build image"
-        depends_on: ~
-        soft_fail: false
-        commands:
-          - "source .buildkite/scripts/docker_login_ecr_public.sh && safe_docker_login_ecr_public"
-          - "docker build -f docker/Dockerfile.rocm -t {{ docker_image_amd }} --progress plain ."
-          - "docker push {{ docker_image_amd }}"
-        key: "amd-build"
-        env:
-          DOCKER_BUILDKIT: "1"
-        retry:
-          automatic:
-            - exit_status: -1  # Agent was lost
-              limit: 1
-            - exit_status: -10  # Agent was lost
-              limit: 1
-            - exit_status: 1  # Machine occasionally fail
-              limit: 1
-        agents:
-          queue: cpu_queue_premerge
-
-    {% for step in steps %}
-    {% if step.mirror_hardwares and mirror_hw in step.mirror_hardwares %}
-      - label: "{{ step.agent_pool }}: {{ step.label }}"
-        depends_on: amd-build
-        agents:
-          {% if step.agent_pool %}
-          queue: amd_{{ step.agent_pool }}
-          {% else %}
-          queue: amd_mi325_1
-          {% endif %}
-        command: bash .buildkite/scripts/hardware_ci/run-amd-test.sh "(command rocm-smi || true) && cd {{ (step.working_dir or default_working_dir) | safe  }} ; {{ step.command  or (step.commands | join(" && ")) | safe }}"
-        env:
-          DOCKER_BUILDKIT: "1"
-        priority: 100
-        {% if step.grade and step.grade == "Blocking" %}
-        soft_fail: false
-        {% else %}
-        soft_fail: true
-        {% endif%}
-    {% endif %}
-    {% endfor %}

.github/ISSUE_TEMPLATE/400-bug-report.yml

@@ -24,7 +24,7 @@ body:
     description: |
       Please run the following and paste the output below.
       ```sh
-      wget https://raw.githubusercontent.com/vllm-project/vllm-omni/main/collect_env.py
+      wget https://raw.githubusercontent.com/vllm-project/vllm-omni/main/vllm_omni/collect_env.py
       # For security purposes, please feel free to check the contents of collect_env.py before running it.
       python collect_env.py
       ```
@@ -40,31 +40,6 @@ body:
       </details>
   validations:
     required: true
-
-- type: textarea
-  attributes:
-    label: Your code version
-    description: |
-      Please provide a description of which commit id or version the code is.
-
-    value: |
-      <details>
-      <summary>The commit id or version of vllm</summary>
-
-      ```text
-
-      ```
-      </details>
-      <details>
-      <summary>The commit id or version of vllm-omni</summary>
-
-      ```text
-
-      ```
-      </details>
-  validations:
-    required: true
-
 - type: textarea
   attributes:
     label: 🐛 Describe the bug

.github/ISSUE_TEMPLATE/750-RFC.yml

@@ -20,8 +20,6 @@ body:
     label: Proposed Change.
     description: >
       The proposed change of the RFC.
-    value: |
-      Please provide the detailed design document of the RFC using the [template](https://docs.google.com/document/d/12YxSsVeD1jvL-InClkeAEnZyWFDndz_65JmXvsamuV4/edit?tab=t.0#heading=h.4ef4szrsgspp).
   validations:
     required: true
 - type: textarea

.github/workflows/build_wheel.yml

@@ -1,61 +0,0 @@
-name: Build Wheel
-
-on:
-  push:
-    branches:
-      - main
-    paths-ignore:
-      - 'docs/**'
-      - 'examples/**'
-      - '.github/**'
-      - '.buildkite/**'
-      - '**.md'
-      - '*.yml'
-      - '.gitignore'
-      - '.gitattributes'
-      - 'LICENSE'
-  pull_request:
-    branches:
-      - main
-    paths-ignore:
-      - 'docs/**'
-      - 'examples/**'
-      - '.github/**'
-      - '.buildkite/**'
-      - '*.yml'
-      - '**.md'
-      - '.gitignore'
-      - '.gitattributes'
-      - 'LICENSE'
-  workflow_dispatch:
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ["3.11", "3.12"]
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Install uv
-        run: |
-          pip install uv
-
-      - name: Build Wheel
-        env:
-          UV_SYSTEM_PYTHON: 1
-        run: |
-          bash scripts/build_wheel.sh --python python
-
-      - name: Upload Wheel Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: vllm-omni-wheel-py${{ matrix.python-version }}
-          path: dist/*.whl

.gitignore

@@ -221,7 +221,6 @@ datasets/
 outputs/
 results/
 generated/
-output_*/
 
 # Configuration overrides
 configs/local.yaml

.pre-commit-config.yaml

@@ -3,7 +3,7 @@ default_install_hook_types:
   - commit-msg
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v6.0.0
+    rev: v4.6.0
     hooks:
       # list of supported hooks: https://pre-commit.com/hooks.html
       - id: check-yaml
@@ -16,20 +16,20 @@ repos:
         args: ["--markdown-linebreak-ext=md"]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.14.10
+    rev: v0.14.0
     hooks:
     - id: ruff-check
       args: [--output-format, github, --fix]
     - id: ruff-format
 
   - repo: https://github.com/crate-ci/typos
-    rev: typos-dict-v0.13.13
+    rev: v1.35.5
     hooks:
       - id: typos
         # only for staged files
 
   - repo: https://github.com/rhysd/actionlint
-    rev: v1.7.9
+    rev: v1.7.7
     hooks:
       - id: actionlint
         files: ^\.github/workflows/.*\.ya?ml$
@@ -58,10 +58,3 @@ repos:
       verbose: true
       pass_filenames: false
     # Insert new entries above the `suggestion` entry
-
-    - id: check-pickle-imports
-      name: Prevent new pickle/cloudpickle imports
-      entry: python tools/pre_commit/check_pickle_imports.py
-      language: python
-      types: [python]
-      additional_dependencies: [regex]

README.md

@@ -9,14 +9,13 @@ Easy, fast, and cheap omni-modality model serving for everyone
 </h3>
 
 <p align="center">
-| <a href="https://vllm-omni.readthedocs.io/en/latest/"><b>Documentation</b></a> | <a href="https://discuss.vllm.ai"><b>User Forum</b></a> | <a href="https://slack.vllm.ai"><b>Developer Slack</b></a> | <a href="docs/assets/WeChat.jpg"><b>WeChat</b></a> |
+| <a href="https://vllm-omni.readthedocs.io/en/latest/"><b>Documentation</b></a> | <a href="https://discuss.vllm.ai"><b>User Forum</b></a> | <a href="https://slack.vllm.ai"><b>Developer Slack</b></a> |
 </p>
 
 ---
 
 *Latest News* 🔥
 
-- [2026/01] We released [0.12.0rc1](https://github.com/vllm-project/vllm-omni/releases/tag/v0.12.0rc1) - a major RC milestone focused on maturing the diffusion stack, strengthening OpenAI-compatible serving, expanding omni-model coverage, and improving stability across platforms (GPU/NPU/ROCm), please check our latest [design](https://docs.google.com/presentation/d/1qv4qMW1rKAqDREMXiUDLIgqqHQe7TDPj/edit?usp=sharing&ouid=110473603432222024453&rtpof=true&sd=true).
 - [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.
 
 ---
@@ -70,10 +69,6 @@ Please check out [Contributing to vLLM-Omni](https://vllm-omni.readthedocs.io/en
 ## Join the Community
 Feel free to ask questions, provide feedbacks and discuss with fellow users of vLLM-Omni in `#sig-omni` slack channel at [slack.vllm.ai](https://slack.vllm.ai) or vLLM user forum at [discuss.vllm.ai](https://discuss.vllm.ai).
 
-## Star History
-
-[![Star History Chart](https://api.star-history.com/svg?repos=vllm-project/vllm-omni&type=date&legend=top-left)](https://www.star-history.com/#vllm-project/vllm-omni&type=date&legend=top-left)
-
 ## License
 
 Apache License 2.0, as found in the [LICENSE](./LICENSE) file.

benchmarks/README.md

@@ -1,42 +0,0 @@
-# Benchmarks Overview and Architecture
-
-This document explains the benchmark architecture across all benchmark assets in this repo. It describes what we measure, and where to find or plug in new scenarios. Per-task details remain in subfolder READMEs (e.g., `benchmarks/<model>/README.md`).
-
-## Scope and goals
-- Establish repeatable latency/throughput measurements for multimodal LLM pipelines.
-- Provide both HF Transformers (offline) and vLLM-Omni (multi-stage/pipeline) baselines.
-- Make it easy to plug in new datasets and models with minimal changes to the runner scripts.
-
-## Dataset and inputs
-- Default example: SeedTTS top-100 prompts (`benchmarks/build_dataset/top100.txt`) via `benchmarks/build_dataset/`.
-- Extensible: drop in new prompt files or modality-aligned payloads; keep the expected format for the consuming scripts (e.g., one prompt per line).
-- If you add a new dataset, document it under `benchmarks/<model>/README.md` and point scripts to your data path.
-
-## Directory layout
-- `benchmarks/build_dataset/` — dataset prep utilities (e.g., SeedTTS top100).
-- `benchmarks/<model>/vllm_omni/` — vLLM-Omni pipeline benchmarks, logs, outputs.
-- Add new tasks under `benchmarks/<model>/...` with the same pattern: `transformers/`, `vllm_omni/`, task-specific README, and (optionally) dataset prep notes.
-
-## Reference workflows
-- **HF Transformers (offline, single process)**  
-  Script (example): `benchmarks/<model>/transformers/eval_qwen3_moe_omni_transformers.sh`  
-  Outputs: `benchmark_results/perf_stats.json`, `benchmark_results/results.json`, `benchmark_results/audio/` (if audio is produced).
-
-- **vLLM-Omni end-to-end pipeline**  
-  Script (example): `benchmarks/<model>/vllm_omni/eval_qwen3_moe_omni.sh`  
-  Outputs: `vllm_omni/logs/*.stats.jsonl` (per-stage/overall latency & TPS), `vllm_omni/logs/stage*.log`, `vllm_omni/outputs/` (text/audio artifacts).
-
-- **Adding a new task/model**  
-  1) Create `benchmarks/<model>/transformers/` and/or `benchmarks/<model>/vllm_omni/` with scripts referencing your model and dataset.  
-  2) Add a task README describing dataset, configs, and expected outputs.  
-  3) Keep the output/log structure similar for easy comparison (perf_stats/results/audio or text outputs; stats.jsonl/logs for pipeline).
-
-## Metrics to watch
-- **Throughput**: `overall_tps`, `*_tps_avg` per stage.
-- **Latency distribution**: look for long tails in `*.stats.jsonl`.
-- **Quality/completeness**: missing outputs or errors in stage logs indicate pipeline failures or misconfigurations.
-
-## Troubleshooting
-- Verify GPU/driver/FlashAttention2 requirements for your chosen model/config.
-- Ensure network access for dataset/model downloads (Google Drive, Hugging Face, etc.).
-- If outputs are missing or slow, inspect per-stage logs and `*.stats.jsonl` for errors, stragglers, or contention.

benchmarks/build_dataset/download_process_data_seedtts.md

@@ -1,82 +0,0 @@
-# Benchmark Dataset Preparation Guide
-
-This guide describes how to download and prepare the SeedTTS test dataset for benchmarking Qwen-Omni models.
-
-## Prerequisites
-
-- Python 3.8+
-- `gdown` for downloading from Google Drive
-- Access to the benchmark scripts
-
-## Steps
-
-### 1. Navigate to the Dataset Directory
-
-```bash
-cd benchmarks/build_dataset
-```
-
-### 2. Install Dependencies
-
-```bash
-pip install gdown
-```
-
-### 3. Download the SeedTTS Test Dataset
-
-Download the dataset from Google Drive:
-
-```bash
-gdown --id 1GlSjVfSHkW3-leKKBlfrjuuTGqQ_xaLP
-```
-
-### 4. Extract the Dataset
-
-```bash
-tar -xf seedtts_testset.tar
-```
-
-### 5. Prepare the Metadata File
-
-Copy the English metadata file to the working directory:
-
-```bash
-cp seedtts_testset/en/meta.lst meta.lst
-```
-
-### 6. Extract Prompts
-
-Extract the first N prompts from the metadata file:
-
-```bash
-# Extract top 100 prompts (adjust -n for different amounts)
-python extract_tts_prompts.py -i meta.lst -o top100.txt -n 100
-```
-
-**Options:**
-- `-i, --input`: Input metadata file (default: `meta.lst`)
-- `-o, --output`: Output prompts file (default: `prompts.txt`)
-- `-n, --num_lines`: Number of prompts to extract (required)
-
-### 7. Clean Up (Optional)
-
-Remove temporary files to save disk space:
-
-```bash
-rm -rf seedtts_testset
-rm seedtts_testset.tar
-rm meta.lst
-```
-
-## Quick Start (All-in-One)
-
-```bash
-# Full setup and benchmark
-cd benchmarks/build_dataset
-pip install gdown
-gdown --id 1GlSjVfSHkW3-leKKBlfrjuuTGqQ_xaLP
-tar -xf seedtts_testset.tar
-cp seedtts_testset/en/meta.lst meta.lst
-python extract_tts_prompts.py -i meta.lst -o top100.txt -n 100
-rm -rf seedtts_testset seedtts_testset.tar meta.lst
-```

benchmarks/build_dataset/extract_tts_prompts.py

@@ -1,73 +0,0 @@
-#!/usr/bin/env python3
-"""
-Extract prompts from meta.lst and save them to a txt file.
-
-Each line in meta.lst has the format:
-ID|prompt_text|audio_path|target_text
-
-This script extracts the prompt_text (second field) from the first N lines.
-"""
-
-import argparse
-from pathlib import Path
-
-
-def extract_prompts(input_file: str, output_file: str, num_lines: int) -> None:
-    """
-    Extract prompts from meta.lst and save to output file.
-
-    Args:
-        input_file: Path to the meta.lst file
-        output_file: Path to the output txt file
-        num_lines: Number of lines to process
-    """
-    prompts = []
-
-    with open(input_file, encoding="utf-8") as f:
-        for i, line in enumerate(f):
-            if i >= num_lines:
-                break
-
-            line = line.strip()
-            if not line:  # Skip empty lines
-                continue
-
-            parts = line.split("|")
-            if len(parts) >= 2:
-                prompt = parts[1]  # The prompt is the second field
-                prompts.append(prompt)
-
-    # Write prompts to output file
-    with open(output_file, "w", encoding="utf-8") as f:
-        for prompt in prompts:
-            f.write(prompt + "\n")
-
-    # Print result stats
-    print(f"Extracted {len(prompts)} prompts from first {num_lines} lines")
-    print(f"Saved to: {output_file}")
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Extract prompts from meta.lst file")
-    parser.add_argument(
-        "-i", "--input", type=str, default="meta.lst", help="Input meta.lst file path (default: meta.lst)"
-    )
-    parser.add_argument(
-        "-o", "--output", type=str, default="prompts.txt", help="Output txt file path (default: prompts.txt)"
-    )
-    parser.add_argument(
-        "-n", "--num_lines", type=int, required=True, help="Number of lines to extract from the beginning"
-    )
-
-    args = parser.parse_args()
-
-    # Check if input file exists
-    if not Path(args.input).exists():
-        print(f"Error: Input file '{args.input}' not found")
-        return
-
-    extract_prompts(args.input, args.output, args.num_lines)
-
-
-if __name__ == "__main__":
-    main()

benchmarks/diffusion/README.md

@@ -1,117 +0,0 @@
-
-# Diffusion Serving Benchmark (Image/Video)
-
-This folder contains an online-serving benchmark script for diffusion models.
-It sends requests to a vLLM OpenAI-compatible endpoint and reports throughput,
-latency percentiles, and optional SLO attainment.
-
-The main entrypoint is:
-
-- `benchmarks/diffusion/diffusion_benchmark_serving.py`
-
-## 1. Quick Start
-
-1. Start the server:
-
-```bash
-vllm serve Qwen/Qwen-Image --omni --port 8099
-```
-
-2. Run a minimal benchmark:
-
-```bash
-python3 benchmarks/diffusion/diffusion_benchmark_serving.py \
-	--base-url http://localhost:8099 \
-	--model Qwen/Qwen-Image \
-	--task t2i \
-	--dataset vbench \
-	--num-prompts 5
-```
-
-**Notes**
-
-- The benchmark talks to `http://<host>:<port>/v1/chat/completions`.
-- If you run the server on another host or port, pass `--base-url` accordingly.
-
-## 2. Supported Datasets
-
-The benchmark supports three dataset modes via `--dataset`:
-
-- `vbench`: Built-in prompt/data loader.
-- `trace`: Heterogeneous request traces (each request can have different resolution/frames/steps).
-- `random`: Synthetic prompts for quick smoke tests.
-
-### VBench dataset
-
-If you use i2v/i2i bench datasets and need auto-download support, you may need:
-
-```bash
-uv pip install gdown
-```
-
-### Trace dataset
-
-Use `--dataset trace` to replay a trace file. The trace can specify per-request fields such as:
-
-- `width`, `height`
-- `num_frames` (video)
-- `num_inference_steps`
-- `seed`, `fps`
-- optional `slo_ms` (per-request SLO target)
-
-By default (when `--dataset-path` is not provided), the script downloads a default trace from
-the HuggingFace dataset repo `asukaqaqzz/Dit_Trace`. The default filename can depend on `--task`
-(e.g., `t2v` uses a video trace).
-
-Current defaults:
-
-- `--task t2i` -> `sd3_trace.txt`
-- `--task t2v` -> `cogvideox_trace.txt`
-
-You can point to your own trace using `--dataset-path`.
-
-## 3. Benchmark Parameters
-
-### Basic flags
-
-- `--base-url`: Server address (the script calls `.../v1/chat/completions`).
-- `--model`: The OpenAI-compatible `model` field.
-- `--task`: Task type (e.g., `t2i`, `t2v`, `i2i`, `i2v`).
-- `--dataset`: Dataset mode (`vbench` / `trace` / `random`).
-- `--num-prompts`: Number of requests to send.
-
-Common optional flags:
-
-- `--output-file`: Write metrics to a JSON file.
-- `--disable-tqdm`: Disable the progress bar.
-
-### Resolution / frames / steps: CLI defaults vs dataset fields
-
-Related flags: `--width`, `--height`, `--num-frames`, `--fps`, `--num-inference-steps`.
-
-- For `vbench` / `random`: these CLI flags act as global defaults for all generated requests.
-- For `trace`: each request can carry its own fields (e.g., `width/height/num_frames/num_inference_steps`).
-
-Precedence rules for `trace` (i.e., what actually gets sent):
-
-- `width/height`: if either `--width` or `--height` is explicitly set, it overrides per-request values from the trace; otherwise per-request values are used when present.
-- `num_frames`: per-request `num_frames` takes precedence; otherwise fall back to `--num-frames`.
-- `num_inference_steps`: per-request `num_inference_steps` takes precedence; otherwise fall back to `--num-inference-steps`.
-
-### SLO, warmup, and max concurrency
-
-Enable SLO evaluation with `--slo`.
-
-- If a request in the trace already has `slo_ms`, that value is used.
-- Otherwise, the script runs warmup requests to infer a base unit time, estimates `expected_ms` by linearly scaling with area/frames/steps, and then sets `slo_ms = expected_ms * --slo-scale`.
-
-Warmup flags:
-
-- `--warmup-requests`: Number of warmup requests.
-- `--warmup-num-inference-steps`: Steps used during warmup.
-- For `--task t2v`: warmup requests are forced to use `num_frames=1` to make warmup faster and less noisy.
-
-Traffic / concurrency flags:
-
-- `--request-rate`: Target request rate (requests/second). If set to `inf`, the script sends all requests immediately.
-- `--max-concurrency`: Max number of in-flight requests (default: `1`). This can hard-cap the achieved QPS: if it is too small, requests will queue behind the semaphore, and both achieved throughput and observed SLO attainment can be skewed.

benchmarks/qwen3-omni/README.md

@@ -1,86 +0,0 @@
-# Benchmarks Guide
-
-This README explains how to (1) prepare benchmark datasets and (2) run the provided Qwen3-Omni benchmarks.
-
-## 1) Prepare the dataset (SeedTTS top100)
-
-```bash
-cd benchmarks/build_dataset
-pip install gdown
-
-# Download SeedTTS test set from Google Drive
-gdown --id 1GlSjVfSHkW3-leKKBlfrjuuTGqQ_xaLP
-
-# Extract
-tar -xf seedtts_testset.tar
-
-# Copy metadata and extract top-100 prompts
-cp seedtts_testset/en/meta.lst meta.lst
-python extract_prompts.py -i meta.lst -o top100.txt -n 100
-
-# (Optional) clean up to save space
-rm -rf seedtts_testset seedtts_testset.tar meta.lst
-```
-
-Artifacts:
-- `benchmarks/build_dataset/top100.txt` — 100 text prompts (one per line).
-
-## 2) Run benchmarks
-
-All commands assume repo root (`vllm-omni`).
-
-### A. Transformers benchmark (offline, HF Transformers)
-
-```
-bash benchmarks/qwen3-omni/transformers/eval_qwen3_moe_omni_transformers.sh
-```
-
-What it does:
-- Runs `qwen3_omni_moe_transformers.py` over `top100.txt` with `--num_prompts 100`.
-- Outputs to `benchmarks/qwen3-omni/transformers/benchmark_results/`:
-  - `perf_stats.json` — aggregated & per-prompt TPS/latency (thinker/talker/code2wav/overall).
-  - `results.json` — per-prompt outputs and audio paths.
-  - `audio/` — ~100 generated `.wav` files.
-
-Key checks:
-- `overall_tps` and `*_tps_avg` should be non-zero and reasonably stable.
-- Investigate any 0/NaN or unusually low TPS / long-tail latency.
-
-### B. vLLM Omni end-to-end benchmark (pipeline)
-
-```
-bash benchmarks/qwen3-omni/vllm_omni/eval_qwen3_moe_omni.sh
-```
-
-What it does:
-- Runs `examples/offline_inference/qwen3_omni/end2end.py` with `--enable-stats`.
-- Uses `benchmarks/build_dataset/top100.txt` and writes to:
-  - Logs: `benchmarks/qwen3-omni/vllm_omni/logs/`
-    - `omni_llm_pipeline_text.orchestrator.stats.jsonl` — per-stage latency stats.
-    - `omni_llm_pipeline_text.overall.stats.jsonl` — end-to-end latency/TPS.
-    - `omni_llm_pipeline_text.stage{0,1,2}.log` — per-stage detailed logs/errors.
-  - Outputs: `benchmarks/qwen3-omni/vllm_omni/outputs/` — ~100 text and `.wav` files.
-
-Key checks:
-- Overall stats: end-to-end latency/TPS should be reasonable.
-- Orchestrator stats: per-stage latency should be stable; investigate long tails.
-- Stage logs: ensure no errors and no unusually slow stages.
-
-
-## Performance snapshot
-
-The chart below summarizes our measured Qwen3-Omni MoE end-to-end benchmark, comparing vLLM-Omni against HF Transformers. It shows the overall throughput advantage for vLLM-Omni. These are actual experiment results—please refer to this performance when evaluating or reproducing the benchmark.
-
-![vLLM-Omni vs HF](./vllm-omni-vs-hf.png)
-
-## Directory layout
-- `benchmarks/build_dataset/` — dataset prep utilities (e.g., SeedTTS top100).
-- `benchmarks/<model>/vllm_omni/` — vLLM-Omni pipeline benchmarks, logs, outputs.
-- Add new tasks under `benchmarks/<model>/...` with the same pattern: `transformers/`, `vllm_omni/`, task-specific README, and (optionally) dataset prep notes.
-- `benchmarks/<model>/vllm-omni-vs-hf.png` — current performance snapshot (overall throughput comparison).
-- `benchmarks/<model>/transformers/` — HF Transformers benchmarks (offline reference).
-
-## Troubleshooting
-- Make sure GPU/driver/FlashAttention2 requirements are met for the chosen model.
-- If downloads fail, confirm network access to Google Drive (`gdown`) and Hugging Face.
-- If audio files are missing, check for errors in stage logs or model generation.***

benchmarks/qwen3-omni/transformers/eval_qwen3_moe_omni_transformers.sh

@@ -1,26 +0,0 @@
-#!/bin/bash
-# Qwen3-Omni Transformers Benchmark Evaluation Script
-# This script must be run from the vllm-omni root directory
-
-# Get the directory where this script is located
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-# Navigate to vllm-omni root directory (4 levels up from script location)
-VLLM_OMNI_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-cd "$VLLM_OMNI_ROOT" || { echo "Error: Failed to navigate to vllm-omni directory"; exit 1; }
-
-echo "Working directory: $(pwd)"
-# Verify we're in the correct directory and run benchmark
-if [[ ! -f "benchmarks/qwen3-omni/transformers/qwen3_omni_moe_transformers.py" ]]; then
-    echo "Error: Not in vllm-omni root directory. Please run from vllm-omni folder."
-else
-    cd benchmarks/qwen3-omni/transformers
-
-    python qwen3_omni_moe_transformers.py --prompts_file ../../build_dataset/top100.txt --num_prompts 100
-
-    echo "Logs and outputs are saved to $(pwd)/benchmark_results:"
-    echo "  - perf_stats.json    Aggregated/per-prompt TPS and latency (thinker/talker/code2wav/overall)"
-    echo "  - results.json       Per-prompt outputs and audio paths"
-    echo "  - audio/             Generated wav files, there should be 100 wav file generated"
-    echo "Key checks: overall_tps and *_tps_avg should be non-zero and stable; investigate 0/NaN or unusually low TPS/long-tail latency."
-fi

benchmarks/qwen3-omni/transformers/qwen3_omni_moe_model.py

@@ -1,265 +0,0 @@
-import time
-
-import torch
-from transformers import Qwen3OmniMoeForConditionalGeneration
-
-
-class Qwen3OmniMoeForConditionalGenerationWithLogging(Qwen3OmniMoeForConditionalGeneration):
-    @torch.no_grad()
-    def generate(
-        self,
-        input_ids: torch.Tensor | None = None,
-        speaker: str = "Ethan",
-        use_audio_in_video: bool = False,
-        return_audio: bool | None = None,
-        thinker_max_new_tokens: int = 1024,
-        thinker_eos_token_id: int = 151645,
-        talker_max_new_tokens: int = 4096,
-        talker_do_sample: bool = True,
-        talker_top_k: int = 50,
-        talker_top_p: float = 1.0,
-        talker_temperature: float = 0.9,
-        talker_repetition_penalty: float = 1.05,
-        **kwargs,
-    ):
-        total_t0 = time.time()
-        perf_stats = {
-            "thinker_tokens": 0,
-            "thinker_time_s": 0.0,
-            "thinker_tps": 0.0,
-            "talker_tokens": 0,
-            "talker_time_s": 0.0,
-            "talker_tps": 0.0,
-            "code2wav_tokens": 0,
-            "code2wav_time_s": 0.0,
-            "code2wav_tps": 0.0,
-            "total_tokens": 0,
-            "total_time_s": 0.0,
-            "total_tps": 0.0,
-        }
-        if return_audio and not self.has_talker:
-            raise ValueError(
-                "Cannot use talker when talker module not initialized. "
-                "Use `enable_talker` method or set enable_talker in config "
-                "to enable talker."
-            )
-        if return_audio is None:
-            return_audio = self.has_talker
-
-        shared_kwargs = {"use_audio_in_video": use_audio_in_video}
-        thinker_kwargs = {
-            "max_new_tokens": thinker_max_new_tokens,
-            "eos_token_id": thinker_eos_token_id,
-        }
-
-        talker_kwargs = {}
-        token2wav_kwargs = {}
-        if return_audio:
-            speaker_id = self.config.talker_config.speaker_id.get(speaker.lower())
-            if speaker_id is None:
-                raise NotImplementedError(f"Speaker {speaker} not implemented")
-            if input_ids.shape[0] != 1:
-                raise NotImplementedError("Qwen3-Omni currently does not support batched inference with audio output")
-            talker_suppressed_tokens = [
-                i
-                for i in range(
-                    self.config.talker_config.text_config.vocab_size - 1024,
-                    self.config.talker_config.text_config.vocab_size,
-                )
-                if i != self.config.talker_config.codec_eos_token_id
-            ]  # Suppress additional special tokens, should not be predicted
-            talker_kwargs = {
-                "max_new_tokens": talker_max_new_tokens,
-                "do_sample": talker_do_sample,
-                "top_k": talker_top_k,
-                "top_p": talker_top_p,
-                "temperature": talker_temperature,
-                "eos_token_id": self.config.talker_config.codec_eos_token_id,
-                "repetition_penalty": talker_repetition_penalty,
-                "suppress_tokens": talker_suppressed_tokens,
-                "output_hidden_states": True,
-                "return_dict_in_generate": True,
-            }
-            token2wav_kwargs = {}
-
-        for key, value in kwargs.items():
-            if key.startswith("thinker_"):
-                thinker_kwargs[key[len("thinker_") :]] = value
-            elif key.startswith("talker_"):
-                talker_kwargs[key[len("talker_") :]] = value
-            elif key.startswith("token2wav_"):
-                token2wav_kwargs[key[len("token2wav_") :]] = value
-            # Process special input values
-            elif key == "feature_attention_mask":
-                thinker_kwargs[key] = value
-                talker_kwargs["audio_feature_lengths"] = torch.sum(value, dim=1)
-            elif key in ("input_features", "attention_mask"):
-                thinker_kwargs[key] = value
-            # Put other key to shared kwargs
-            else:
-                shared_kwargs[key] = value
-
-        # Merge kwargs
-        for key, value in shared_kwargs.items():
-            if key not in thinker_kwargs:
-                thinker_kwargs[key] = value
-            if key not in talker_kwargs and key in ["image_grid_thw", "video_grid_thw", "video_second_per_grid"]:
-                talker_kwargs[key] = value
-            if key not in token2wav_kwargs:
-                token2wav_kwargs[key] = value
-
-        # 1. Generate from thinker module
-        generate_audio = return_audio and self.has_talker
-        if generate_audio:
-            thinker_kwargs["output_hidden_states"] = True
-            thinker_kwargs["return_dict_in_generate"] = True
-
-        t0 = time.time()
-        thinker_result = self.thinker.generate(input_ids=input_ids, **thinker_kwargs)
-        t1 = time.time()
-        perf_stats["thinker_time_s"] = max(0.0, t1 - t0)
-        try:
-            prompt_len = int(input_ids.shape[1]) if input_ids is not None else 0
-            total_len = int(thinker_result.sequences.shape[-1])
-            thinker_out_len = max(0, total_len - prompt_len)
-        except Exception:
-            thinker_out_len = 0
-        perf_stats["thinker_tokens"] = thinker_out_len
-        perf_stats["thinker_tps"] = (
-            (thinker_out_len / perf_stats["thinker_time_s"]) if perf_stats["thinker_time_s"] > 0 else 0.0
-        )
-
-        if not generate_audio:
-            perf_stats["total_tokens"] = perf_stats["thinker_tokens"]
-            perf_stats["total_time_s"] = time.time() - total_t0
-            perf_stats["total_tps"] = (
-                (perf_stats["total_tokens"] / perf_stats["total_time_s"]) if perf_stats["total_time_s"] > 0 else 0.0
-            )
-            # attach stats to self
-            setattr(self, "_perf_stats_last", perf_stats)
-            if not hasattr(self, "_perf_stats_history"):
-                setattr(self, "_perf_stats_history", [])
-            self._perf_stats_history.append(perf_stats)
-            return thinker_result, None
-
-        # 2. Prepare talker input
-        thinker_embed = torch.cat([hidden_states[0] for hidden_states in thinker_result.hidden_states], dim=1).to(
-            self.talker.device
-        )  # [1 t d]
-        thinker_hidden = torch.cat(
-            [
-                hidden_states[self.config.talker_config.accept_hidden_layer]
-                for hidden_states in thinker_result.hidden_states
-            ],
-            dim=1,
-        ).to(self.talker.device)  # [1 t d]
-
-        im_start_indexes = torch.cat(
-            (
-                torch.nonzero(input_ids[0] == self.config.im_start_token_id).squeeze(),
-                torch.tensor([thinker_result.sequences.shape[-1]], device=input_ids.device, dtype=input_ids.dtype),
-            ),
-            dim=-1,
-        ).to(self.talker.device)  # Shape [n_starts + 1]; Take batch 0 since batched inference is not supported here.
-        multimodal_mask = (
-            (thinker_result.sequences == self.config.thinker_config.audio_token_id) |
-            (thinker_result.sequences == self.config.thinker_config.image_token_id) |
-            (thinker_result.sequences == self.config.thinker_config.video_token_id)
-        ).to(self.talker.device)  # [1 t] # fmt: skip
-
-        talker_special_tokens = torch.tensor(
-            [[self.config.tts_bos_token_id, self.config.tts_eos_token_id, self.config.tts_pad_token_id]],
-            device=self.thinker.device,
-            dtype=input_ids.dtype,
-        )
-        tts_bos_embed, tts_eos_embed, tts_pad_embed = (
-            self.talker.text_projection(self.thinker.get_input_embeddings()(talker_special_tokens))
-            .to(self.talker.device)
-            .chunk(3, dim=1)
-        )  # 3 * [1 1 d]
-
-        talker_input_embeds = []  # [1 t d]
-        talker_input_ids = []
-        # For every chatml parts
-        for i in range(len(im_start_indexes) - 1):
-            im_start_index = im_start_indexes[i]
-            segment_end_index = im_start_indexes[i + 1]
-            role_token = input_ids[0][im_start_index + 1]
-            # Talker should ignore thinker system prompt
-            if role_token == self.config.system_token_id:
-                continue
-            # Talker takes word embeddings for tokens and hidden state from `accept_hidden_layer` for multimodal inputs
-            elif role_token == self.config.user_token_id:
-                talker_user_part = self._get_talker_user_parts(
-                    im_start_index, segment_end_index, multimodal_mask, thinker_hidden, thinker_embed
-                )
-                talker_input_embeds.append(talker_user_part)
-                talker_input_ids.append(thinker_result.sequences[:, im_start_index:segment_end_index])
-            # Take assistant output (for now)
-            elif role_token == self.config.assistant_token_id and i == len(im_start_indexes) - 2:
-                talker_assistant_embeds, talker_assistant_ids, trailing_text_hidden = self._get_talker_assistant_parts(
-                    im_start_index,
-                    segment_end_index,
-                    speaker_id,
-                    thinker_embed,
-                    tts_pad_embed,
-                    tts_bos_embed,
-                    tts_eos_embed,
-                )
-                talker_input_embeds.append(talker_assistant_embeds)
-                talker_input_ids.append(talker_assistant_ids)
-            # History assistant output (ignore for now)
-            elif role_token == self.config.assistant_token_id and i != len(im_start_indexes) - 2:
-                continue
-            else:
-                raise AssertionError("Expect role id after <|im_start|> (assistant, user, system)")
-        talker_input_embed = torch.cat([embed.to(self.talker.device) for embed in talker_input_embeds], dim=1)
-        talker_input_id = torch.cat([embed.to(self.talker.device) for embed in talker_input_ids], dim=1)
-        t2 = time.time()
-        talker_result = self.talker.generate(
-            inputs_embeds=talker_input_embed,
-            trailing_text_hidden=trailing_text_hidden,
-            tts_pad_embed=tts_pad_embed,
-            talker_input_ids=talker_input_id,  # Not use input_ids to prevent repetition penalty out of bound
-            **talker_kwargs,
-        )
-        t3 = time.time()
-        perf_stats["talker_time_s"] = max(0.0, t3 - t2)
-        talker_codes = (
-            torch.stack([hid[-1] for hid in talker_result.hidden_states if hid[-1] is not None], dim=1)
-            .transpose(1, 2)
-            .to(self.code2wav.device)
-        )
-        try:
-            # codes shape: (B, num_quantizers, T). We log T as token length.
-            perf_stats["talker_tokens"] = int(talker_codes.shape[-1])
-        except Exception:
-            perf_stats["talker_tokens"] = 0
-        perf_stats["talker_tps"] = (
-            (perf_stats["talker_tokens"] / perf_stats["talker_time_s"]) if perf_stats["talker_time_s"] > 0 else 0.0
-        )
-        t4 = time.time()
-        talker_wavs = self.code2wav.chunked_decode(talker_codes, chunk_size=300, left_context_size=25).float()
-        t5 = time.time()
-        perf_stats["code2wav_time_s"] = max(0.0, t5 - t4)
-        perf_stats["code2wav_tokens"] = perf_stats["talker_tokens"]  # same T, not times 16
-        perf_stats["code2wav_tps"] = (
-            (perf_stats["code2wav_tokens"] / perf_stats["code2wav_time_s"])
-            if perf_stats["code2wav_time_s"] > 0
-            else 0.0
-        )
-        perf_stats["total_tokens"] = perf_stats["thinker_tokens"] + perf_stats["talker_tokens"]
-        perf_stats["total_time_s"] = time.time() - total_t0
-        perf_stats["total_tps"] = (
-            (perf_stats["total_tokens"] / perf_stats["total_time_s"]) if perf_stats["total_time_s"] > 0 else 0.0
-        )
-        setattr(self, "_perf_stats_last", perf_stats)
-        if not hasattr(self, "_perf_stats_history"):
-            setattr(self, "_perf_stats_history", [])
-        self._perf_stats_history.append(perf_stats)
-        return thinker_result, talker_wavs.float()
-
-
-__all__ = [
-    "Qwen3OmniMoeForConditionalGenerationWithLogging",
-]

benchmarks/qwen3-omni/transformers/qwen3_omni_moe_transformers.py

@@ -1,275 +0,0 @@
-import argparse
-import json
-import os
-
-import soundfile as sf
-from qwen3_omni_moe_model import Qwen3OmniMoeForConditionalGenerationWithLogging
-from qwen_omni_utils import process_mm_info
-from tqdm import tqdm
-from transformers import Qwen3OmniMoeProcessor
-
-MODEL_PATH = "Qwen/Qwen3-Omni-30B-A3B-Instruct"
-# MODEL_PATH = "Qwen/Qwen3-Omni-30B-A3B-Thinking"
-
-
-def load_prompts(prompts_file: str) -> list[str]:
-    """Load prompts from a text file, one prompt per line."""
-    prompts = []
-    with open(prompts_file, encoding="utf-8") as f:
-        for line in f:
-            line = line.strip()
-            if line:
-                prompts.append(line)
-    return prompts
-
-
-def run_benchmark(
-    model,
-    processor,
-    prompts: list[str],
-    output_dir: str = "benchmark_results",
-    speaker: str = "Ethan",
-    use_audio_in_video: bool = True,
-):
-    """
-    Run benchmark on a list of prompts and collect performance stats.
-
-    Args:
-        model: The Qwen3OmniMoe model
-        processor: The Qwen3OmniMoe processor
-        prompts: List of text prompts to process
-        output_dir: Directory to save results
-        speaker: Speaker voice for audio output
-        use_audio_in_video: Whether to use audio in video
-
-    Returns:
-        tuple: (aggregated_stats, results, audio_outputs)
-            - aggregated_stats: dict with aggregated performance statistics
-            - results: list of dicts with per-prompt results
-            - audio_outputs: list of audio tensors/arrays (or None if no audio)
-    """
-    os.makedirs(output_dir, exist_ok=True)
-    audio_dir = os.path.join(output_dir, "audio")
-    os.makedirs(audio_dir, exist_ok=True)
-
-    all_stats = []
-    results = []
-    audio_outputs = []
-
-    for idx, prompt in enumerate(tqdm(prompts, desc="Processing prompts")):
-        conversation = [
-            {
-                "role": "user",
-                "content": [{"type": "text", "text": prompt}],
-            },
-        ]
-
-        # Preparation for inference
-        text = processor.apply_chat_template(conversation, add_generation_prompt=True, tokenize=False)
-        audios, images, videos = process_mm_info(conversation, use_audio_in_video=use_audio_in_video)
-        inputs = processor(
-            text=text,
-            audio=audios,
-            images=images,
-            videos=videos,
-            return_tensors="pt",
-            padding=True,
-            use_audio_in_video=use_audio_in_video,
-        )
-        inputs = inputs.to(model.device).to(model.dtype)
-
-        # Inference: Generation of the output text and audio
-        text_ids, audio = model.generate(
-            **inputs, speaker=speaker, thinker_return_dict_in_generate=True, use_audio_in_video=use_audio_in_video
-        )
-
-        # Decode output text
-        output_text = processor.batch_decode(
-            text_ids.sequences[:, inputs["input_ids"].shape[1] :],
-            skip_special_tokens=True,
-            clean_up_tokenization_spaces=False,
-        )[0]
-
-        # Collect performance stats
-        perf_stats = None
-        if hasattr(model, "_perf_stats_last"):
-            perf_stats = model._perf_stats_last.copy()
-            perf_stats["prompt_idx"] = idx
-            perf_stats["prompt"] = prompt
-            all_stats.append(perf_stats)
-
-        # Save audio and collect audio output
-        audio_path = None
-        audio_data = None
-        if audio is not None:
-            audio_data = audio.reshape(-1).detach().cpu().numpy()
-            audio_path = os.path.join(audio_dir, f"output_{idx:04d}.wav")
-            sf.write(
-                audio_path,
-                audio_data,
-                samplerate=24000,
-            )
-            audio_outputs.append(audio_data)
-        else:
-            audio_outputs.append(None)
-
-        # Save result
-        result = {
-            "idx": idx,
-            "prompt": prompt,
-            "output": output_text,
-            "audio_path": audio_path,
-            "perf_stats": perf_stats,
-        }
-        results.append(result)
-
-    # Aggregate statistics
-    aggregated_stats = aggregate_stats(all_stats)
-
-    # Save all results
-    results_path = os.path.join(output_dir, "results.json")
-    with open(results_path, "w", encoding="utf-8") as f:
-        json.dump(results, f, ensure_ascii=False, indent=2)
-
-    # Save aggregated stats
-    stats_path = os.path.join(output_dir, "perf_stats.json")
-    with open(stats_path, "w", encoding="utf-8") as f:
-        json.dump({"aggregated": aggregated_stats, "per_prompt": all_stats}, f, ensure_ascii=False, indent=2)
-
-    # Count saved audio files
-    num_audio_saved = sum(1 for a in audio_outputs if a is not None)
-    print(f"\nSaved {num_audio_saved} audio files to {audio_dir}/")
-
-    return aggregated_stats, results, audio_outputs
-
-
-def aggregate_stats(all_stats: list[dict]) -> dict:
-    """Aggregate performance statistics from multiple runs."""
-    if not all_stats:
-        return {}
-
-    keys = [
-        "thinker_tokens",
-        "thinker_time_s",
-        "thinker_tps",
-        "talker_tokens",
-        "talker_time_s",
-        "talker_tps",
-        "code2wav_tokens",
-        "code2wav_time_s",
-        "code2wav_tps",
-        "total_tokens",
-        "total_time_s",
-        "total_tps",
-    ]
-
-    aggregated = {
-        "num_samples": len(all_stats),
-    }
-
-    for key in keys:
-        values = [s.get(key, 0) for s in all_stats if key in s]
-        if values:
-            aggregated[f"{key}_sum"] = sum(values)
-            aggregated[f"{key}_avg"] = sum(values) / len(values)
-            aggregated[f"{key}_min"] = min(values)
-            aggregated[f"{key}_max"] = max(values)
-
-    # Calculate overall throughput
-    total_tokens = aggregated.get("total_tokens_sum", 0)
-    total_time = aggregated.get("total_time_s_sum", 0)
-    if total_time > 0:
-        aggregated["overall_tps"] = total_tokens / total_time
-
-    return aggregated
-
-
-def print_stats(stats: dict):
-    """Print performance statistics in a formatted way."""
-    print("\n" + "=" * 60)
-    print("Performance Statistics Summary")
-    print("=" * 60)
-
-    print(f"\nNumber of samples: {stats.get('num_samples', 0)}")
-
-    print("\n--- Thinker ---")
-    print(f"  Total tokens:  {stats.get('thinker_tokens_sum', 0):.0f}")
-    print(f"  Total time:    {stats.get('thinker_time_s_sum', 0):.2f}s")
-    print(f"  Avg TPS:       {stats.get('thinker_tps_avg', 0):.2f}")
-    print(f"  Min TPS:       {stats.get('thinker_tps_min', 0):.2f}")
-    print(f"  Max TPS:       {stats.get('thinker_tps_max', 0):.2f}")
-
-    print("\n--- Talker ---")
-    print(f"  Total tokens:  {stats.get('talker_tokens_sum', 0):.0f}")
-    print(f"  Total time:    {stats.get('talker_time_s_sum', 0):.2f}s")
-    print(f"  Avg TPS:       {stats.get('talker_tps_avg', 0):.2f}")
-    print(f"  Min TPS:       {stats.get('talker_tps_min', 0):.2f}")
-    print(f"  Max TPS:       {stats.get('talker_tps_max', 0):.2f}")
-
-    print("\n--- Code2Wav ---")
-    print(f"  Total tokens:  {stats.get('code2wav_tokens_sum', 0):.0f}")
-    print(f"  Total time:    {stats.get('code2wav_time_s_sum', 0):.2f}s")
-    print(f"  Avg TPS:       {stats.get('code2wav_tps_avg', 0):.2f}")
-    print(f"  Min TPS:       {stats.get('code2wav_tps_min', 0):.2f}")
-    print(f"  Max TPS:       {stats.get('code2wav_tps_max', 0):.2f}")
-
-    print("\n--- Overall ---")
-    print(f"  Total tokens:  {stats.get('total_tokens_sum', 0):.0f}")
-    print(f"  Total time:    {stats.get('total_time_s_sum', 0):.2f}s")
-    print(f"  Overall TPS:   {stats.get('overall_tps', 0):.2f}")
-    print(f"  Avg TPS:       {stats.get('total_tps_avg', 0):.2f}")
-    print(f"  Min TPS:       {stats.get('total_tps_min', 0):.2f}")
-    print(f"  Max TPS:       {stats.get('total_tps_max', 0):.2f}")
-
-    print("=" * 60 + "\n")
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Qwen3-Omni Benchmark Script")
-    parser.add_argument(
-        "--prompts_file",
-        type=str,
-        default="benchmark/build_dataset/top100.txt",
-        help="Path to the prompts file (one prompt per line)",
-    )
-    parser.add_argument(
-        "--output_dir", type=str, default="benchmark_results", help="Directory to save benchmark results"
-    )
-    parser.add_argument("--model_path", type=str, default=MODEL_PATH, help="Path to the model")
-    parser.add_argument("--speaker", type=str, default="Ethan", help="Speaker voice for audio output")
-    parser.add_argument("--num_prompts", type=int, default=None, help="Number of prompts to process (default: all)")
-    args = parser.parse_args()
-
-    # Load model and processor
-    print(f"Loading model from {args.model_path}...")
-    model = Qwen3OmniMoeForConditionalGenerationWithLogging.from_pretrained(
-        args.model_path,
-        dtype="auto",
-        device_map="auto",
-        attn_implementation="flash_attention_2",
-    )
-    processor = Qwen3OmniMoeProcessor.from_pretrained(args.model_path)
-
-    # Benchmark mode
-    print(f"Loading prompts from {args.prompts_file}...")
-    prompts = load_prompts(args.prompts_file)
-
-    if args.num_prompts:
-        prompts = prompts[: args.num_prompts]
-
-    print(f"Running benchmark on {len(prompts)} prompts...")
-
-    aggregated_stats, results, audio_outputs = run_benchmark(
-        model=model,
-        processor=processor,
-        prompts=prompts,
-        output_dir=args.output_dir,
-        speaker=args.speaker,
-    )
-
-    print_stats(aggregated_stats)
-    print(f"\nResults saved to {args.output_dir}/")
-
-
-if __name__ == "__main__":
-    main()

benchmarks/qwen3-omni/vllm_omni/eval_qwen3_moe_omni.sh

@@ -1,37 +0,0 @@
-#!/bin/bash
-# Qwen3-Omni Benchmark Evaluation Script
-# This script must be run from the vllm-omni root directory
-
-# Get the directory where this script is located
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-# Navigate to vllm-omni root directory (4 levels up from script location)
-VLLM_OMNI_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-cd "$VLLM_OMNI_ROOT" || { echo "Error: Failed to navigate to vllm-omni directory"; exit 1; }
-
-echo "Working directory: $(pwd)"
-
-# Verify we're in the correct directory and run benchmark
-if [[ ! -d "benchmarks/qwen3-omni/vllm_omni" ]]; then
-    echo "Error: Not in vllm-omni root directory. Please run from vllm-omni folder."
-else
-    log_dir=benchmarks/qwen3-omni/vllm_omni/logs
-    outputs_dir=benchmarks/qwen3-omni/vllm_omni/outputs
-    end2end_script_path=examples/offline_inference/qwen3_omni/end2end.py
-    build_dataset_path=benchmarks/build_dataset/top100.txt
-
-    python $end2end_script_path --output-wav $outputs_dir \
-                      --query-type text \
-                      --txt-prompts $build_dataset_path \
-                      --enable-stats \
-                      --log-dir $log_dir
-    echo "Logs and outputs are saved in ${log_dir} and ${outputs_dir} respectively:"
-    echo "  - omni_llm_pipeline_text                       run dir/base name"
-    echo "  - omni_llm_pipeline_text.orchestrator.stats.jsonl  orchestrator-stage latency stats"
-    echo "  - omni_llm_pipeline_text.overall.stats.jsonl       overall latency/TPS stats"
-    echo "  - omni_llm_pipeline_text.stage0.log                per-stage detailed logs"
-    echo "  - omni_llm_pipeline_text.stage1.log"
-    echo "  - omni_llm_pipeline_text.stage2.log"
-    echo "Key checks: overall.stats.jsonl for end-to-end latency/TPS; orchestrator.stats.jsonl for stable per-stage latency; stage*.log for errors or long tails."
-    echo "  - outputs/             Generated txt and wav files, there should be 100 text and wav files generated respectively"
-fi

collect_env.py

@@ -1,760 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-# ruff: noqa
-# code borrowed from https://github.com/pytorch/pytorch/blob/main/torch/utils/collect_env.py
-
-import datetime
-import locale
-import os
-import subprocess
-import sys
-
-# Unlike the rest of the PyTorch this file must be python2 compliant.
-# This script outputs relevant system environment info
-# Run it with `python collect_env.py` or `python -m torch.utils.collect_env`
-from collections import namedtuple
-
-import regex as re
-
-from vllm.envs import environment_variables
-
-try:
-    import torch
-
-    TORCH_AVAILABLE = True
-except (ImportError, NameError, AttributeError, OSError):
-    TORCH_AVAILABLE = False
-
-# System Environment Information
-SystemEnv = namedtuple(
-    "SystemEnv",
-    [
-        "torch_version",
-        "is_debug_build",
-        "cuda_compiled_version",
-        "gcc_version",
-        "clang_version",
-        "cmake_version",
-        "os",
-        "libc_version",
-        "python_version",
-        "python_platform",
-        "is_cuda_available",
-        "cuda_runtime_version",
-        "cuda_module_loading",
-        "nvidia_driver_version",
-        "nvidia_gpu_models",
-        "cudnn_version",
-        "pip_version",  # 'pip' or 'pip3'
-        "pip_packages",
-        "conda_packages",
-        "hip_compiled_version",
-        "hip_runtime_version",
-        "miopen_runtime_version",
-        "caching_allocator_config",
-        "is_xnnpack_available",
-        "cpu_info",
-        "rocm_version",  # vllm specific field
-        "vllm_version",  # vllm specific field
-        "vllm_omni_version",  # vllm-omni specific field
-        "vllm_build_flags",  # vllm specific field
-        "gpu_topo",  # vllm specific field
-        "env_vars",
-    ],
-)
-
-DEFAULT_CONDA_PATTERNS = {
-    "torch",
-    "numpy",
-    "cudatoolkit",
-    "soumith",
-    "mkl",
-    "magma",
-    "triton",
-    "optree",
-    "nccl",
-    "transformers",
-    "zmq",
-    "nvidia",
-    "pynvml",
-    "flashinfer-python",
-}
-
-DEFAULT_PIP_PATTERNS = {
-    "torch",
-    "numpy",
-    "mypy",
-    "flake8",
-    "triton",
-    "optree",
-    "onnx",
-    "nccl",
-    "transformers",
-    "zmq",
-    "nvidia",
-    "pynvml",
-    "flashinfer-python",
-}
-
-
-def run(command):
-    """Return (return-code, stdout, stderr)."""
-    shell = True if type(command) is str else False
-    try:
-        p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=shell)
-        raw_output, raw_err = p.communicate()
-        rc = p.returncode
-        if get_platform() == "win32":
-            enc = "oem"
-        else:
-            enc = locale.getpreferredencoding()
-        output = raw_output.decode(enc)
-        if command == "nvidia-smi topo -m":
-            # don't remove the leading whitespace of `nvidia-smi topo -m`
-            #   because they are meaningful
-            output = output.rstrip()
-        else:
-            output = output.strip()
-        err = raw_err.decode(enc)
-        return rc, output, err.strip()
-
-    except FileNotFoundError:
-        cmd_str = command if isinstance(command, str) else command[0]
-        return 127, "", f"Command not found: {cmd_str}"
-
-
-def run_and_read_all(run_lambda, command):
-    """Run command using run_lambda; reads and returns entire output if rc is 0."""
-    rc, out, _ = run_lambda(command)
-    if rc != 0:
-        return None
-    return out
-
-
-def run_and_parse_first_match(run_lambda, command, regex):
-    """Run command using run_lambda, returns the first regex match if it exists."""
-    rc, out, _ = run_lambda(command)
-    if rc != 0:
-        return None
-    match = re.search(regex, out)
-    if match is None:
-        return None
-    return match.group(1)
-
-
-def run_and_return_first_line(run_lambda, command):
-    """Run command using run_lambda and returns first line if output is not empty."""
-    rc, out, _ = run_lambda(command)
-    if rc != 0:
-        return None
-    return out.split("\n")[0]
-
-
-def get_conda_packages(run_lambda, patterns=None):
-    if patterns is None:
-        patterns = DEFAULT_CONDA_PATTERNS
-    conda = os.environ.get("CONDA_EXE", "conda")
-    out = run_and_read_all(run_lambda, [conda, "list"])
-    if out is None:
-        return out
-
-    return "\n".join(
-        line for line in out.splitlines() if not line.startswith("#") and any(name in line for name in patterns)
-    )
-
-
-def get_gcc_version(run_lambda):
-    return run_and_parse_first_match(run_lambda, "gcc --version", r"gcc (.*)")
-
-
-def get_clang_version(run_lambda):
-    return run_and_parse_first_match(run_lambda, "clang --version", r"clang version (.*)")
-
-
-def get_cmake_version(run_lambda):
-    return run_and_parse_first_match(run_lambda, "cmake --version", r"cmake (.*)")
-
-
-def get_nvidia_driver_version(run_lambda):
-    if get_platform() == "darwin":
-        cmd = "kextstat | grep -i cuda"
-        return run_and_parse_first_match(run_lambda, cmd, r"com[.]nvidia[.]CUDA [(](.*?)[)]")
-    smi = get_nvidia_smi()
-    return run_and_parse_first_match(run_lambda, smi, r"Driver Version: (.*?) ")
-
-
-def get_gpu_info(run_lambda):
-    if get_platform() == "darwin" or (
-        TORCH_AVAILABLE and hasattr(torch.version, "hip") and torch.version.hip is not None
-    ):
-        if TORCH_AVAILABLE and torch.cuda.is_available():
-            if torch.version.hip is not None:
-                prop = torch.cuda.get_device_properties(0)
-                if hasattr(prop, "gcnArchName"):
-                    gcnArch = " ({})".format(prop.gcnArchName)
-                else:
-                    gcnArch = "NoGCNArchNameOnOldPyTorch"
-            else:
-                gcnArch = ""
-            return torch.cuda.get_device_name(None) + gcnArch
-        return None
-    smi = get_nvidia_smi()
-    uuid_regex = re.compile(r" \(UUID: .+?\)")
-    rc, out, _ = run_lambda(smi + " -L")
-    if rc != 0:
-        return None
-    # Anonymize GPUs by removing their UUID
-    return re.sub(uuid_regex, "", out)
-
-
-def get_running_cuda_version(run_lambda):
-    return run_and_parse_first_match(run_lambda, "nvcc --version", r"release .+ V(.*)")
-
-
-def get_cudnn_version(run_lambda):
-    """Return a list of libcudnn.so; it's hard to tell which one is being used."""
-    if get_platform() == "win32":
-        system_root = os.environ.get("SYSTEMROOT", "C:\\Windows")
-        cuda_path = os.environ.get("CUDA_PATH", "%CUDA_PATH%")
-        where_cmd = os.path.join(system_root, "System32", "where")
-        cudnn_cmd = '{} /R "{}\\bin" cudnn*.dll'.format(where_cmd, cuda_path)
-    elif get_platform() == "darwin":
-        # CUDA libraries and drivers can be found in /usr/local/cuda/. See
-        # https://docs.nvidia.com/cuda/cuda-installation-guide-mac-os-x/index.html#install
-        # https://docs.nvidia.com/deeplearning/sdk/cudnn-install/index.html#installmac
-        # Use CUDNN_LIBRARY when cudnn library is installed elsewhere.
-        cudnn_cmd = "ls /usr/local/cuda/lib/libcudnn*"
-    else:
-        cudnn_cmd = 'ldconfig -p | grep libcudnn | rev | cut -d" " -f1 | rev'
-    rc, out, _ = run_lambda(cudnn_cmd)
-    # find will return 1 if there are permission errors or if not found
-    if len(out) == 0 or (rc != 1 and rc != 0):
-        l = os.environ.get("CUDNN_LIBRARY")
-        if l is not None and os.path.isfile(l):
-            return os.path.realpath(l)
-        return None
-    files_set = set()
-    for fn in out.split("\n"):
-        fn = os.path.realpath(fn)  # eliminate symbolic links
-        if os.path.isfile(fn):
-            files_set.add(fn)
-    if not files_set:
-        return None
-    # Alphabetize the result because the order is non-deterministic otherwise
-    files = sorted(files_set)
-    if len(files) == 1:
-        return files[0]
-    result = "\n".join(files)
-    return "Probably one of the following:\n{}".format(result)
-
-
-def get_nvidia_smi():
-    # Note: nvidia-smi is currently available only on Windows and Linux
-    smi = "nvidia-smi"
-    if get_platform() == "win32":
-        system_root = os.environ.get("SYSTEMROOT", "C:\\Windows")
-        program_files_root = os.environ.get("PROGRAMFILES", "C:\\Program Files")
-        legacy_path = os.path.join(program_files_root, "NVIDIA Corporation", "NVSMI", smi)
-        new_path = os.path.join(system_root, "System32", smi)
-        smis = [new_path, legacy_path]
-        for candidate_smi in smis:
-            if os.path.exists(candidate_smi):
-                smi = '"{}"'.format(candidate_smi)
-                break
-    return smi
-
-
-def get_rocm_version(run_lambda):
-    """Returns the ROCm version if available, otherwise 'N/A'."""
-    return run_and_parse_first_match(run_lambda, "hipcc --version", r"HIP version: (\S+)")
-
-
-def get_vllm_version():
-    from vllm import __version__, __version_tuple__
-
-    if __version__ == "dev":
-        return "N/A (dev)"
-    version_str = __version_tuple__[-1]
-    if isinstance(version_str, str) and version_str.startswith("g"):
-        # it's a dev build
-        if "." in version_str:
-            # it's a dev build containing local changes
-            git_sha = version_str.split(".")[0][1:]
-            date = version_str.split(".")[-1][1:]
-            return f"{__version__} (git sha: {git_sha}, date: {date})"
-        else:
-            # it's a dev build without local changes
-            git_sha = version_str[1:]  # type: ignore
-            return f"{__version__} (git sha: {git_sha})"
-    return __version__
-
-
-def get_vllm_omni_version(run_lambda):
-    try:
-        import vllm_omni
-        from vllm_omni import __version__, __version_tuple__
-
-        version_str = __version_tuple__[-1]
-        if isinstance(version_str, str) and version_str.startswith("g"):
-            if "." in version_str:
-                git_sha = version_str.split(".")[0][1:]
-                date = version_str.split(".")[-1][1:]
-                return f"{__version__} (git sha: {git_sha}, date: {date})"
-            else:
-                git_sha = version_str[1:]
-                return f"{__version__} (git sha: {git_sha})"
-
-        package_dir = os.path.dirname(os.path.abspath(vllm_omni.__file__))
-        git_sha = run_and_read_all(run_lambda, f"git -C {package_dir} rev-parse --short HEAD")
-        if git_sha:
-            return f"{__version__} (git sha: {git_sha})"
-
-        return __version__
-    except ImportError:
-        return "N/A (vllm_omni not installed)"
-
-
-def summarize_vllm_build_flags():
-    # This could be a static method if the flags are constant, or dynamic if you need to check environment variables, etc.
-    return "CUDA Archs: {}; ROCm: {}".format(
-        os.environ.get("TORCH_CUDA_ARCH_LIST", "Not Set"),
-        "Enabled" if os.environ.get("ROCM_HOME") else "Disabled",
-    )
-
-
-def get_gpu_topo(run_lambda):
-    output = None
-
-    if get_platform() == "linux":
-        output = run_and_read_all(run_lambda, "nvidia-smi topo -m")
-        if output is None:
-            output = run_and_read_all(run_lambda, "rocm-smi --showtopo")
-
-    return output
-
-
-def get_cpu_info(run_lambda):
-    rc, out, err = 0, "", ""
-    if get_platform() == "linux":
-        rc, out, err = run_lambda("lscpu")
-    elif get_platform() == "win32":
-        rc, out, err = run_lambda(
-            "wmic cpu get Name,Manufacturer,Family,Architecture,ProcessorType,DeviceID, \
-        CurrentClockSpeed,MaxClockSpeed,L2CacheSize,L2CacheSpeed,Revision /VALUE"
-        )
-    elif get_platform() == "darwin":
-        rc, out, err = run_lambda("sysctl -n machdep.cpu.brand_string")
-    cpu_info = "None"
-    if rc == 0:
-        cpu_info = out
-    else:
-        cpu_info = err
-    return cpu_info
-
-
-def get_platform():
-    if sys.platform.startswith("linux"):
-        return "linux"
-    elif sys.platform.startswith("win32"):
-        return "win32"
-    elif sys.platform.startswith("cygwin"):
-        return "cygwin"
-    elif sys.platform.startswith("darwin"):
-        return "darwin"
-    else:
-        return sys.platform
-
-
-def get_mac_version(run_lambda):
-    return run_and_parse_first_match(run_lambda, "sw_vers -productVersion", r"(.*)")
-
-
-def get_windows_version(run_lambda):
-    system_root = os.environ.get("SYSTEMROOT", "C:\\Windows")
-    wmic_cmd = os.path.join(system_root, "System32", "Wbem", "wmic")
-    findstr_cmd = os.path.join(system_root, "System32", "findstr")
-    return run_and_read_all(run_lambda, "{} os get Caption | {} /v Caption".format(wmic_cmd, findstr_cmd))
-
-
-def get_lsb_version(run_lambda):
-    return run_and_parse_first_match(run_lambda, "lsb_release -a", r"Description:\t(.*)")
-
-
-def check_release_file(run_lambda):
-    return run_and_parse_first_match(run_lambda, "cat /etc/*-release", r'PRETTY_NAME="(.*)"')
-
-
-def get_os(run_lambda):
-    from platform import machine
-
-    platform = get_platform()
-
-    if platform == "win32" or platform == "cygwin":
-        return get_windows_version(run_lambda)
-
-    if platform == "darwin":
-        version = get_mac_version(run_lambda)
-        if version is None:
-            return None
-        return "macOS {} ({})".format(version, machine())
-
-    if platform == "linux":
-        # Ubuntu/Debian based
-        desc = get_lsb_version(run_lambda)
-        if desc is not None:
-            return "{} ({})".format(desc, machine())
-
-        # Try reading /etc/*-release
-        desc = check_release_file(run_lambda)
-        if desc is not None:
-            return "{} ({})".format(desc, machine())
-
-        return "{} ({})".format(platform, machine())
-
-    # Unknown platform
-    return platform
-
-
-def get_python_platform():
-    import platform
-
-    return platform.platform()
-
-
-def get_libc_version():
-    import platform
-
-    if get_platform() != "linux":
-        return "N/A"
-    return "-".join(platform.libc_ver())
-
-
-def is_uv_venv():
-    if os.environ.get("UV"):
-        return True
-    pyvenv_cfg_path = os.path.join(sys.prefix, "pyvenv.cfg")
-    if os.path.exists(pyvenv_cfg_path):
-        with open(pyvenv_cfg_path, "r") as f:
-            return any(line.startswith("uv = ") for line in f)
-    return False
-
-
-def get_pip_packages(run_lambda, patterns=None):
-    """Return `pip list` output. Note: will also find conda-installed pytorch and numpy packages."""
-    if patterns is None:
-        patterns = DEFAULT_PIP_PATTERNS
-
-    def run_with_pip():
-        try:
-            import importlib.util
-
-            pip_spec = importlib.util.find_spec("pip")
-            pip_available = pip_spec is not None
-        except ImportError:
-            pip_available = False
-
-        if pip_available:
-            cmd = [sys.executable, "-mpip", "list", "--format=freeze"]
-        elif is_uv_venv():
-            print("uv is set")
-            cmd = ["uv", "pip", "list", "--format=freeze"]
-        else:
-            raise RuntimeError("Could not collect pip list output (pip or uv module not available)")
-
-        out = run_and_read_all(run_lambda, cmd)
-        return "\n".join(line for line in out.splitlines() if any(name in line for name in patterns))
-
-    pip_version = "pip3" if sys.version[0] == "3" else "pip"
-    out = run_with_pip()
-    return pip_version, out
-
-
-def get_cachingallocator_config():
-    ca_config = os.environ.get("PYTORCH_CUDA_ALLOC_CONF", "")
-    return ca_config
-
-
-def get_cuda_module_loading_config():
-    if TORCH_AVAILABLE and torch.cuda.is_available():
-        torch.cuda.init()
-        config = os.environ.get("CUDA_MODULE_LOADING", "")
-        return config
-    else:
-        return "N/A"
-
-
-def is_xnnpack_available():
-    if TORCH_AVAILABLE:
-        import torch.backends.xnnpack
-
-        return str(torch.backends.xnnpack.enabled)  # type: ignore[attr-defined]
-    else:
-        return "N/A"
-
-
-def get_env_vars():
-    env_vars = ""
-    secret_terms = ("secret", "token", "api", "access", "password")
-    report_prefix = (
-        "TORCH",
-        "NCCL",
-        "PYTORCH",
-        "CUDA",
-        "CUBLAS",
-        "CUDNN",
-        "OMP_",
-        "MKL_",
-        "NVIDIA",
-    )
-    for k, v in os.environ.items():
-        if any(term in k.lower() for term in secret_terms):
-            continue
-        if k in environment_variables:
-            env_vars = env_vars + "{}={}".format(k, v) + "\n"
-        if k.startswith(report_prefix):
-            env_vars = env_vars + "{}={}".format(k, v) + "\n"
-
-    return env_vars
-
-
-def get_env_info():
-    run_lambda = run
-    pip_version, pip_list_output = get_pip_packages(run_lambda)
-
-    if TORCH_AVAILABLE:
-        version_str = torch.__version__
-        debug_mode_str = str(torch.version.debug)
-        cuda_available_str = str(torch.cuda.is_available())
-        cuda_version_str = torch.version.cuda
-        if not hasattr(torch.version, "hip") or torch.version.hip is None:  # cuda version
-            hip_compiled_version = hip_runtime_version = miopen_runtime_version = "N/A"
-        else:  # HIP version
-
-            def get_version_or_na(cfg, prefix):
-                _lst = [s.rsplit(None, 1)[-1] for s in cfg if prefix in s]
-                return _lst[0] if _lst else "N/A"
-
-            cfg = torch._C._show_config().split("\n")
-            hip_runtime_version = get_version_or_na(cfg, "HIP Runtime")
-            miopen_runtime_version = get_version_or_na(cfg, "MIOpen")
-            cuda_version_str = "N/A"
-            hip_compiled_version = torch.version.hip
-    else:
-        version_str = debug_mode_str = cuda_available_str = cuda_version_str = "N/A"
-        hip_compiled_version = hip_runtime_version = miopen_runtime_version = "N/A"
-
-    sys_version = sys.version.replace("\n", " ")
-
-    conda_packages = get_conda_packages(run_lambda)
-
-    rocm_version = get_rocm_version(run_lambda)
-    vllm_version = get_vllm_version()
-    vllm_omni_version = get_vllm_omni_version(run_lambda)
-    vllm_build_flags = summarize_vllm_build_flags()
-    gpu_topo = get_gpu_topo(run_lambda)
-
-    return SystemEnv(
-        torch_version=version_str,
-        is_debug_build=debug_mode_str,
-        python_version="{} ({}-bit runtime)".format(sys_version, sys.maxsize.bit_length() + 1),
-        python_platform=get_python_platform(),
-        is_cuda_available=cuda_available_str,
-        cuda_compiled_version=cuda_version_str,
-        cuda_runtime_version=get_running_cuda_version(run_lambda),
-        cuda_module_loading=get_cuda_module_loading_config(),
-        nvidia_gpu_models=get_gpu_info(run_lambda),
-        nvidia_driver_version=get_nvidia_driver_version(run_lambda),
-        cudnn_version=get_cudnn_version(run_lambda),
-        hip_compiled_version=hip_compiled_version,
-        hip_runtime_version=hip_runtime_version,
-        miopen_runtime_version=miopen_runtime_version,
-        pip_version=pip_version,
-        pip_packages=pip_list_output,
-        conda_packages=conda_packages,
-        os=get_os(run_lambda),
-        libc_version=get_libc_version(),
-        gcc_version=get_gcc_version(run_lambda),
-        clang_version=get_clang_version(run_lambda),
-        cmake_version=get_cmake_version(run_lambda),
-        caching_allocator_config=get_cachingallocator_config(),
-        is_xnnpack_available=is_xnnpack_available(),
-        cpu_info=get_cpu_info(run_lambda),
-        rocm_version=rocm_version,
-        vllm_version=vllm_version,
-        vllm_omni_version=vllm_omni_version,
-        vllm_build_flags=vllm_build_flags,
-        gpu_topo=gpu_topo,
-        env_vars=get_env_vars(),
-    )
-
-
-env_info_fmt = """
-==============================
-        System Info
-==============================
-OS                           : {os}
-GCC version                  : {gcc_version}
-Clang version                : {clang_version}
-CMake version                : {cmake_version}
-Libc version                 : {libc_version}
-
-==============================
-       PyTorch Info
-==============================
-PyTorch version              : {torch_version}
-Is debug build               : {is_debug_build}
-CUDA used to build PyTorch   : {cuda_compiled_version}
-ROCM used to build PyTorch   : {hip_compiled_version}
-
-==============================
-      Python Environment
-==============================
-Python version               : {python_version}
-Python platform              : {python_platform}
-
-==============================
-       CUDA / GPU Info
-==============================
-Is CUDA available            : {is_cuda_available}
-CUDA runtime version         : {cuda_runtime_version}
-CUDA_MODULE_LOADING set to   : {cuda_module_loading}
-GPU models and configuration : {nvidia_gpu_models}
-Nvidia driver version        : {nvidia_driver_version}
-cuDNN version                : {cudnn_version}
-HIP runtime version          : {hip_runtime_version}
-MIOpen runtime version       : {miopen_runtime_version}
-Is XNNPACK available         : {is_xnnpack_available}
-
-==============================
-          CPU Info
-==============================
-{cpu_info}
-
-==============================
-Versions of relevant libraries
-==============================
-{pip_packages}
-{conda_packages}
-""".strip()
-
-# both the above code and the following code use `strip()` to
-# remove leading/trailing whitespaces, so we need to add a newline
-# in between to separate the two sections
-env_info_fmt += "\n\n"
-
-env_info_fmt += """
-==============================
-         vLLM Info
-==============================
-ROCM Version                 : {rocm_version}
-vLLM Version                 : {vllm_version}
-vLLM-Omni Version            : {vllm_omni_version}
-vLLM Build Flags:
-  {vllm_build_flags}
-GPU Topology:
-  {gpu_topo}
-
-==============================
-     Environment Variables
-==============================
-{env_vars}
-""".strip()
-
-
-def pretty_str(envinfo):
-    def replace_nones(dct, replacement="Could not collect"):
-        for key in dct.keys():
-            if dct[key] is not None:
-                continue
-            dct[key] = replacement
-        return dct
-
-    def replace_bools(dct, true="Yes", false="No"):
-        for key in dct.keys():
-            if dct[key] is True:
-                dct[key] = true
-            elif dct[key] is False:
-                dct[key] = false
-        return dct
-
-    def prepend(text, tag="[prepend]"):
-        lines = text.split("\n")
-        updated_lines = [tag + line for line in lines]
-        return "\n".join(updated_lines)
-
-    def replace_if_empty(text, replacement="No relevant packages"):
-        if text is not None and len(text) == 0:
-            return replacement
-        return text
-
-    def maybe_start_on_next_line(string):
-        # If `string` is multiline, prepend a \n to it.
-        if string is not None and len(string.split("\n")) > 1:
-            return "\n{}\n".format(string)
-        return string
-
-    mutable_dict = envinfo._asdict()
-
-    # If nvidia_gpu_models is multiline, start on the next line
-    mutable_dict["nvidia_gpu_models"] = maybe_start_on_next_line(envinfo.nvidia_gpu_models)
-
-    # If the machine doesn't have CUDA, report some fields as 'No CUDA'
-    dynamic_cuda_fields = [
-        "cuda_runtime_version",
-        "nvidia_gpu_models",
-        "nvidia_driver_version",
-    ]
-    all_cuda_fields = dynamic_cuda_fields + ["cudnn_version"]
-    all_dynamic_cuda_fields_missing = all(mutable_dict[field] is None for field in dynamic_cuda_fields)
-    if TORCH_AVAILABLE and not torch.cuda.is_available() and all_dynamic_cuda_fields_missing:
-        for field in all_cuda_fields:
-            mutable_dict[field] = "No CUDA"
-        if envinfo.cuda_compiled_version is None:
-            mutable_dict["cuda_compiled_version"] = "None"
-
-    # Replace True with Yes, False with No
-    mutable_dict = replace_bools(mutable_dict)
-
-    # Replace all None objects with 'Could not collect'
-    mutable_dict = replace_nones(mutable_dict)
-
-    # If either of these are '', replace with 'No relevant packages'
-    mutable_dict["pip_packages"] = replace_if_empty(mutable_dict["pip_packages"])
-    mutable_dict["conda_packages"] = replace_if_empty(mutable_dict["conda_packages"])
-
-    # Tag conda and pip packages with a prefix
-    # If they were previously None, they'll show up as ie '[conda] Could not collect'
-    if mutable_dict["pip_packages"]:
-        mutable_dict["pip_packages"] = prepend(mutable_dict["pip_packages"], "[{}] ".format(envinfo.pip_version))
-    if mutable_dict["conda_packages"]:
-        mutable_dict["conda_packages"] = prepend(mutable_dict["conda_packages"], "[conda] ")
-    mutable_dict["cpu_info"] = envinfo.cpu_info
-    return env_info_fmt.format(**mutable_dict)
-
-
-def get_pretty_env_info():
-    return pretty_str(get_env_info())
-
-
-def main():
-    print("Collecting environment information...")
-    output = get_pretty_env_info()
-    print(output)
-
-    if TORCH_AVAILABLE and hasattr(torch, "utils") and hasattr(torch.utils, "_crash_handler"):
-        minidump_dir = torch.utils._crash_handler.DEFAULT_MINIDUMP_DIR
-        if sys.platform == "linux" and os.path.exists(minidump_dir):
-            dumps = [os.path.join(minidump_dir, dump) for dump in os.listdir(minidump_dir)]
-            latest = max(dumps, key=os.path.getctime)
-            ctime = os.path.getctime(latest)
-            creation_time = datetime.datetime.fromtimestamp(ctime).strftime("%Y-%m-%d %H:%M:%S")
-            msg = (
-                "\n*** Detected a minidump at {} created on {}, ".format(latest, creation_time)
-                + "if this is related to your bug please include it when you file a report ***"
-            )
-            print(msg, file=sys.stderr)
-
-
-if __name__ == "__main__":
-    main()

docker/Dockerfile.ci

@@ -1,17 +1,11 @@
 ARG VLLM_BASE_IMAGE=vllm/vllm-openai
-ARG VLLM_BASE_TAG=v0.12.0
+ARG VLLM_BASE_TAG=v0.11.0
 FROM ${VLLM_BASE_IMAGE}:${VLLM_BASE_TAG}
 ARG APP_DIR=/workspace/vllm-omni
 WORKDIR ${APP_DIR}
 
 COPY . .
 
-# Install system dependencies
-RUN apt-get update && \
-    apt-get install -y ffmpeg && \
-    apt-get clean && \
-    rm -rf /var/lib/apt/lists/*
-
 # Install vllm-omni into the same uv-managed Python environment used by the base image.
 RUN uv pip install --python "$(python3 -c 'import sys; print(sys.executable)')" --no-cache-dir ".[dev]"
 

docker/Dockerfile.ci.npu

@@ -1,15 +0,0 @@
-ARG VLLM_ASCEND_IMAGE=quay.nju.edu.cn/ascend/vllm-ascend
-ARG VLLM_ASCEND_TAG=v0.11.0rc2
-FROM ${VLLM_ASCEND_IMAGE}:${VLLM_ASCEND_TAG}
-
-ARG APP_DIR=/vllm-workspace/vllm-omni
-WORKDIR ${APP_DIR}
-
-COPY . .
-
-# Install vllm-omni with dev dependencies
-RUN pip install --no-cache-dir -e ".[dev]"
-
-ENV VLLM_WORKER_MULTIPROC_METHOD=spawn
-
-ENTRYPOINT []

docker/Dockerfile.rocm

@@ -1,42 +0,0 @@
-ARG BASE_IMAGE=rocm/vllm-dev:nightly_main_20251205
-FROM ${BASE_IMAGE}
-
-ARG COMMON_WORKDIR=/app
-ARG VLLM_VERSION=v0.12.0
-ARG PYTORCH_ROCM_ARCH="gfx942;gfx950"
-
-WORKDIR ${COMMON_WORKDIR}
-
-# Step 1: Setup - Install system dependencies
-RUN apt-get update && \
-    apt-get install -y ffmpeg && \
-    apt-get clean && \
-    rm -rf /var/lib/apt/lists/*
-
-# Step 2: Reinstall vllm from source
-RUN python3 -m pip uninstall -y vllm && rm -rf vllm &&\
-    git clone https://github.com/vllm-project/vllm.git && \
-    cd vllm && \
-    git checkout ${VLLM_VERSION} && \
-    python3 -m pip install -r requirements/rocm.txt && \
-    python3 setup.py clean --all && \
-    PYTORCH_ROCM_ARCH=${PYTORCH_ROCM_ARCH} python3 setup.py develop && \
-    cd ../ && \
-    rm -rf vllm/.git
-
-RUN mkdir -p ${COMMON_WORKDIR}/vllm-omni
-
-# Step 3: Copy vllm-omni code and install without uv
-COPY . ${COMMON_WORKDIR}/vllm-omni
-RUN cd ${COMMON_WORKDIR}/vllm-omni && python3 -m pip install --no-cache-dir ".[dev]"
-
-# Create python symlink
-# `GPU_ARCHS` is an environment variable that is used to set the GPU archs for the AITER.
-# This is needed to prevent the AITER automatic GPU arch detection from failing on MI325X.
-# The AITER version used in this dockerfile has issues with handling
-# the GPU archs of MI325X (CI machine) correctly. So we manually set the GPU archs here.
-# We reuse AITER_ROCM_ARCH from the base image to avoid duplication.
-ENV GPU_ARCHS=${AITER_ROCM_ARCH}
-RUN ln -sf /usr/bin/python3 /usr/bin/python
-
-ENTRYPOINT []

docs/.nav.yml

@@ -3,39 +3,27 @@ nav:
 - User Guide:
   - Getting Started:
     - getting_started/quickstart.md
-    - getting_started/installation/*
-  - Serving:
-    - OpenAI-Compatible API:
-      - Image Generation: serving/image_generation_api.md
+    - getting_started/installation
   - Examples:
     - examples/README.md
     - Offline Inference:
-      - Image-To-Image: user_guide/examples/offline_inference/image_to_image.md
-      - Image-To-Video: user_guide/examples/offline_inference/image_to_video.md
       - Qwen2.5-Omni: user_guide/examples/offline_inference/qwen2_5_omni.md
       - Qwen3-Omni: user_guide/examples/offline_inference/qwen3_omni.md
       - Text-To-Image: user_guide/examples/offline_inference/text_to_image.md
+      - Image-To-Image: user_guide/examples/offline_inference/image_to_image.md
       - Text-To-Video: user_guide/examples/offline_inference/text_to_video.md
     - Online Serving:
-      - Image-To-Image: user_guide/examples/online_serving/image_to_image.md
       - Qwen2.5-Omni: user_guide/examples/online_serving/qwen2_5_omni.md
       - Qwen3-Omni: user_guide/examples/online_serving/qwen3_omni.md
-      - Text-To-Image: user_guide/examples/online_serving/text_to_image.md
   - General:
     - usage/*
   - Configuration:
     - configuration/README.md
     - configuration/*
+  - Diffusion Acceleration:
+     - TeaCache: user_guide/teacache.md
   - Models:
     - models/supported_models.md
-  - Features:
-    - Sleep Mode: features/sleep_mode.md
-    - Diffusion Features:
-      - Overview: user_guide/diffusion_acceleration.md
-      - TeaCache: user_guide/diffusion/teacache.md
-      - Cache-DiT: user_guide/diffusion/cache_dit_acceleration.md
-      - Parallelism Acceleration: user_guide/diffusion/parallelism_acceleration.md
-      - CPU Offloading: user_guide/diffusion/cpu_offload_diffusion.md
 - Developer Guide:
   - General:
     - contributing/README.md
@@ -43,19 +31,18 @@ nav:
       flatten_single_child_sections: true
   - Model Implementation:
     - contributing/model/README.md
-    - contributing/model/adding_omni_model.md
-    - contributing/model/adding_diffusion_model.md
   - CI: contributing/ci
   - Design Documents:
     - design/index.md
     - design/architecture_overview.md
     - Feature Design:
-      - design/feature/disaggregated_inference.md
+      - design/feature/multi_request_streaming_design.md
+      - design/feature/omni_connector_design.md
       - design/feature/ray_based_execution.md
     - Module Design:
-      - design/module/ar_module.md
-      - design/module/dit_module.md
-      - design/module/entrypoint_module.md
+      - design/module/ar_module_design.md
+      - design/module/dit_module_design.md
+      - design/module/entrypoint_module_design.md
   - Docs Guide: contributing/DOCS_GUIDE.md
 - API Reference:
   - api/README.md

docs/README.md

@@ -60,5 +60,5 @@ vLLM-Omni seamlessly supports most popular open-source models on HuggingFace, in
 
 For more information, checkout the following:
 
-- [vllm-omni architecture design and recent roadmaps](https://docs.google.com/presentation/d/1qv4qMW1rKAqDREMXiUDLIgqqHQe7TDPj/edit?usp=sharing&ouid=110473603432222024453&rtpof=true&sd=true)
+- [vllm-omni architecture design and recent roadmaps](https://docs.google.com/presentation/d/1Y7t2Zm3BIISPN-_X_sDpxZMNCWir2rAx/edit?usp=drive_link&ouid=110473603432222024453&rtpof=true&sd=true)
 - [vllm-omni announcement blogpost](https://blog.vllm.ai/2025/11/30/vllm-omni.html)

docs/api/README.md

@@ -5,22 +5,17 @@
 Main entry points for vLLM-Omni inference and serving.
 
 - [vllm_omni.entrypoints.async_omni.AsyncOmni][]
-- [vllm_omni.entrypoints.async_omni_diffusion.AsyncOmniDiffusion][]
-- [vllm_omni.entrypoints.async_omni_llm.AsyncOmniLLM][]
+- [vllm_omni.entrypoints.async_omni.AsyncOmniStageLLM][]
 - [vllm_omni.entrypoints.chat_utils.OmniAsyncMultiModalContentParser][]
 - [vllm_omni.entrypoints.chat_utils.OmniAsyncMultiModalItemTracker][]
 - [vllm_omni.entrypoints.chat_utils.parse_chat_messages_futures][]
 - [vllm_omni.entrypoints.cli.serve.OmniServeCommand][]
-- [vllm_omni.entrypoints.client_request_state.ClientRequestState][]
 - [vllm_omni.entrypoints.log_utils.OrchestratorMetrics][]
-- [vllm_omni.entrypoints.log_utils.StageRequestMetrics][]
-- [vllm_omni.entrypoints.log_utils.StageStats][]
 - [vllm_omni.entrypoints.omni.Omni][]
-- [vllm_omni.entrypoints.omni.OmniBase][]
-- [vllm_omni.entrypoints.omni_diffusion.OmniDiffusion][]
 - [vllm_omni.entrypoints.omni_llm.OmniLLM][]
+- [vllm_omni.entrypoints.omni_llm.OmniStageLLM][]
 - [vllm_omni.entrypoints.omni_stage.OmniStage][]
-- [vllm_omni.entrypoints.stage_utils.OmniStageTaskType][]
+- [vllm_omni.entrypoints.openai.serving_chat.OmniOpenAIServingChat][]
 
 ## Inputs
 
@@ -36,7 +31,6 @@ Input data structures for multi-modal inputs.
 
 Engine classes for offline and online inference.
 
-- [vllm_omni.diffusion.diffusion_engine.BackgroundResources][]
 - [vllm_omni.diffusion.diffusion_engine.DiffusionEngine][]
 - [vllm_omni.engine.AdditionalInformationEntry][]
 - [vllm_omni.engine.AdditionalInformationPayload][]
@@ -46,14 +40,15 @@ Engine classes for offline and online inference.
 - [vllm_omni.engine.PromptEmbedsPayload][]
 - [vllm_omni.engine.arg_utils.AsyncOmniEngineArgs][]
 - [vllm_omni.engine.arg_utils.OmniEngineArgs][]
-- [vllm_omni.engine.input_processor.OmniInputProcessor][]
 - [vllm_omni.engine.output_processor.MultimodalOutputProcessor][]
 - [vllm_omni.engine.output_processor.OmniRequestState][]
+- [vllm_omni.engine.processor.OmniProcessor][]
 
 ## Core
 
 Core scheduling and caching components.
 
+- [vllm_omni.core.dit_cache_manager.DiTCacheManager][]
 - [vllm_omni.core.sched.omni_ar_scheduler.OmniARScheduler][]
 - [vllm_omni.core.sched.omni_generation_scheduler.OmniGenerationScheduler][]
 - [vllm_omni.core.sched.output.OmniNewRequestData][]
@@ -62,12 +57,16 @@ Core scheduling and caching components.
 
 Model execution components.
 
-- [vllm_omni.model_executor.custom_process_mixin.CustomProcessMixin][]
 - [vllm_omni.model_executor.models.output_templates.OmniOutput][]
 - [vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni.Qwen2_5OmniForConditionalGeneration][]
 - [vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_talker.Qwen2_5OmniTalkerForConditionalGeneration][]
+- [vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_thinker.Qwen2_5OmniAudioFeatureInputs][]
 - [vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_thinker.Qwen2_5OmniConditionalGenerationMixin][]
+- [vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_thinker.Qwen2_5OmniThinkerDummyInputsBuilder][]
 - [vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_thinker.Qwen2_5OmniThinkerForConditionalGeneration][]
+- [vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_thinker.Qwen2_5OmniThinkerMultiModalDataParser][]
+- [vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_thinker.Qwen2_5OmniThinkerMultiModalProcessor][]
+- [vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_thinker.Qwen2_5OmniThinkerProcessingInfo][]
 - [vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_token2wav.Qwen2_5OmniToken2WavBigVGANModel][]
 - [vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_token2wav.Qwen2_5OmniToken2WavDiTModel][]
 - [vllm_omni.model_executor.models.qwen2_5_omni.qwen2_5_omni_token2wav.Qwen2_5OmniToken2WavForConditionalGenerationVLLM][]
@@ -82,13 +81,15 @@ Model execution components.
 - [vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_code_predictor_mtp.Qwen3OmniMoeTalkerCodePredictor][]
 - [vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_talker.Qwen3OmniMoeModel][]
 - [vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_talker.Qwen3OmniMoeTalkerForConditionalGeneration][]
-- [vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_talker.Qwen3OmniMoeTalkerSharedExpertWrapper][]
 - [vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_thinker.Qwen3MoeLLMForCausalLM][]
 - [vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_thinker.Qwen3MoeLLMModel][]
 - [vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_thinker.Qwen3OmniMoeConditionalGenerationMixin][]
 - [vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_thinker.Qwen3OmniMoeThinkerForConditionalGeneration][]
 - [vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_thinker.Qwen3OmniMoeThinkerMultiModalProcessor][]
 - [vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_thinker.Qwen3OmniMoeThinkerProcessingInfo][]
+- [vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_thinker.Qwen3Omni_VisionTransformer][]
+- [vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_thinker.Qwen3_VisionPatchEmbed][]
+- [vllm_omni.model_executor.models.qwen3_omni.qwen3_omni_moe_thinker.Qwen3_VisionPatchMerger][]
 
 ## Configuration
 
@@ -96,25 +97,20 @@ Configuration classes.
 
 - [vllm_omni.config.model.OmniModelConfig][]
 - [vllm_omni.diffusion.cache.teacache.config.TeaCacheConfig][]
-- [vllm_omni.distributed.omni_connectors.utils.config.ConnectorSpec][]
-- [vllm_omni.distributed.omni_connectors.utils.config.OmniTransferConfig][]
 
 ## Workers
 
 Worker classes and model runners for distributed inference.
 
-- [vllm_omni.diffusion.worker.gpu_diffusion_model_runner.GPUDiffusionModelRunner][]
-- [vllm_omni.diffusion.worker.gpu_diffusion_worker.GPUDiffusionWorker][]
-- [vllm_omni.diffusion.worker.gpu_diffusion_worker.WorkerProc][]
+- [vllm_omni.diffusion.worker.gpu_worker.GPUWorker][]
+- [vllm_omni.diffusion.worker.gpu_worker.WorkerProc][]
 - [vllm_omni.diffusion.worker.npu.npu_worker.NPUWorker][]
 - [vllm_omni.diffusion.worker.npu.npu_worker.NPUWorkerProc][]
-- [vllm_omni.worker.gpu_ar_model_runner.ExecuteModelState][]
 - [vllm_omni.worker.gpu_ar_model_runner.GPUARModelRunner][]
 - [vllm_omni.worker.gpu_ar_worker.GPUARWorker][]
 - [vllm_omni.worker.gpu_generation_model_runner.GPUGenerationModelRunner][]
 - [vllm_omni.worker.gpu_generation_worker.GPUGenerationWorker][]
 - [vllm_omni.worker.gpu_model_runner.OmniGPUModelRunner][]
-- [vllm_omni.worker.npu.npu_ar_model_runner.ExecuteModelState][]
 - [vllm_omni.worker.npu.npu_ar_model_runner.NPUARModelRunner][]
 - [vllm_omni.worker.npu.npu_ar_worker.NPUARWorker][]
 - [vllm_omni.worker.npu.npu_generation_model_runner.NPUGenerationModelRunner][]

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.12.0/configuration/index.html)
+For options within a vLLM Engine. Please refer to [vLLM Configuration](https://docs.vllm.ai/en/v0.11.0/configuration/index.html)
 
 Currently, the main options are maintained by stage configs for each model.
 
@@ -10,12 +10,6 @@ For specific example, please refer to [Qwen2.5-omni stage config](stage_configs/
 
 For introduction, please check [Introduction for stage config](./stage_configs.md)
 
-## Memory Configuration
-
-- **[GPU Memory Calculation and Configuration](./gpu_memory_utilization.md)** - Guide on how to calculate memory requirements and set up `gpu_memory_utilization` for optimal performance
-
 ## Optimization Features
 
-- **[TeaCache Configuration](../user_guide/diffusion/teacache.md)** - Enable TeaCache adaptive caching for DiT models to achieve 1.5x-2.0x speedup with minimal quality loss
-- **[Cache-DiT Configuration](../user_guide/diffusion/cache_dit_acceleration.md)** - Enable Cache-DiT as cache acceleration backends for DiT models
-- **[Parallelism Configuration](../user_guide/diffusion/parallelism_acceleration.md)** - Enable parallelism (e.g., sequence parallelism) for for DiT models
+- **[TeaCache Configuration](../user_guide/teacache.md)** - Enable TeaCache adaptive caching for DiT models to achieve 1.5x-2.0x speedup with minimal quality loss

docs/configuration/gpu_memory_utilization.md

@@ -1,207 +0,0 @@
-# GPU Memory Calculation and Configuration
-
-This guide explains how to calculate GPU memory requirements and properly configure `gpu_memory_utilization` for vLLM-Omni stages.
-
-## Overview
-
-`gpu_memory_utilization` is a critical parameter that controls how much GPU memory each stage can use. It's specified as a fraction between 0.0 and 1.0, where:
-- `0.8` means 80% of the GPU's total memory
-- `1.0` means 100% of the GPU's total memory (not recommended, leaves no buffer)
-
-## How Memory is Calculated
-
-### Memory Allocation Formula
-
-For each stage, vLLM-Omni calculates the requested memory as:
-
-```
-requested_memory = total_gpu_memory × gpu_memory_utilization
-```
-
-The system checks that:
-```
-free_memory ≥ requested_memory
-```
-
-If this condition is not met, the stage will fail to initialize with an error message showing the memory requirements.
-
-### Memory Components
-
-The total memory used by a stage includes:
-
-1. **Model Weights**: The size of the model parameters loaded on the GPU
-2. **KV Cache**: Memory for storing key-value cache during generation
-3. **Activation Memory**: Temporary memory for intermediate computations
-4. **System Overhead**: Memory used by CUDA, PyTorch, and other system components
-5. **Non-Torch Memory**: Memory allocated outside of PyTorch (e.g., CUDA graphs)
-
-### Example Calculation
-
-For a GPU with 80GB total memory:
-- `gpu_memory_utilization: 0.8` → 64GB available for the stage
-- `gpu_memory_utilization: 0.6` → 48GB available for the stage
-- `gpu_memory_utilization: 0.15` → 12GB available for the stage
-
-## Setting Up `gpu_memory_utilization`
-
-### Step 1: Determine GPU Memory
-
-First, check your GPU's total memory:
-
-```bash
-# Using nvidia-smi
-nvidia-smi --query-gpu=memory.total --format=csv
-
-# Or using Python
-python -c "import torch; print(f'{torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB')"
-```
-
-### Step 2: Estimate Model Memory Requirements
-
-#### For Autoregressive (AR) Stages
-
-AR stages typically need more memory due to:
-- Large model weights
-- KV cache for attention
-- Activation buffers
-
-#### For Diffusion/Generation Stages
-
-Diffusion stages (like code2wav) typically need less memory:
-- Smaller model components
-- Different memory access patterns
-
-**Typical values:**
-- `0.1 - 0.3` for most diffusion stages
-
-### Step 3: Consider Multi-Stage Scenarios
-
-When multiple stages share the same GPU, you must ensure the sum of their `gpu_memory_utilization` values doesn't exceed 1.0.
-
-**Example: Two stages on GPU 0**
-```yaml
-stage_args:
-  - stage_id: 0
-    runtime:
-      devices: "0"
-    engine_args:
-      gpu_memory_utilization: 0.6  # Uses 60% of GPU 0
-
-  - stage_id: 1
-    runtime:
-      devices: "0"
-    engine_args:
-      gpu_memory_utilization: 0.3  # Uses 30% of GPU 0
-      # Total: 90% of GPU 0 (safe, leaves 10% buffer)
-```
-
-**Important:** If stages run on different GPUs, each can use up to 1.0 independently.
-
-### Step 4: Account for Tensor Parallelism
-
-When using `tensor_parallel_size > 1`, the model is split across multiple GPUs, so each GPU needs less memory.
-
-**Example: 2-way tensor parallelism**
-```yaml
-stage_args:
-  - stage_id: 0
-    runtime:
-      devices: "0,1"  # Uses both GPUs
-    engine_args:
-      tensor_parallel_size: 2
-      gpu_memory_utilization: 0.6  # 60% per GPU
-      # Model is split, so each GPU uses ~30% of model memory
-```
-
-## Examples
-
-### Qwen3-Omni-MoE on 2x H100-80GB
-
-```yaml
-stage_args:
-  - stage_id: 0  # Thinker stage with TP=2
-    runtime:
-      devices: "0,1"
-    engine_args:
-      tensor_parallel_size: 2
-      gpu_memory_utilization: 0.6  # 48GB per GPU
-
-  - stage_id: 1  # Talker stage
-    runtime:
-      devices: "1"
-    engine_args:
-      gpu_memory_utilization: 0.3  # 24GB on GPU 1
-
-  - stage_id: 2  # Code2Wav stage
-    runtime:
-      devices: "0"
-    engine_args:
-      gpu_memory_utilization: 0.1  # 8GB on GPU 0
-```
-**Note:** In this configuration, stages 0 and 2 share GPU 0, but they run at different times in the pipeline, so their memory usage doesn't overlap.
-
-## Troubleshooting
-
-### Error: "Free memory is less than desired GPU memory utilization"
-
-This means the GPU doesn't have enough free memory when the stage starts.
-
-**Solutions:**
-1. Free up memory by closing other processes
-2. Reduce `gpu_memory_utilization` for this stage
-3. Use a GPU with more memory
-4. Move the stage to a different GPU
-
-### Error: OOM during inference
-
-The stage initialized but ran out of memory during processing.
-
-**Solutions:**
-1. Reduce `max_num_batched_tokens`
-2. Reduce `max_batch_size` in runtime config
-3. Lower `gpu_memory_utilization` slightly
-4. Enable quantization if supported
-
-### Memory Not Fully Utilized
-
-If you see low memory usage, you can:
-1. Increase `gpu_memory_utilization` to allow larger KV cache
-2. Increase `max_num_batched_tokens` for better batching
-3. Check if other stages are limiting throughput
-
-## Useful formula for Memory Calculation
-
-### KV Cache Memory
-
-The KV cache size depends on:
-- Number of sequences in batch
-- Sequence length (prompt + generation)
-- Model hidden size
-- Number of attention heads
-- Number of layers
-
-approximate Formula:
-```
-kv_cache_memory ≈ batch_size × seq_len × hidden_size × num_layers × 2 × dtype_size
-```
-2 for k & v
-
-### Model Weight Memory
-
-```
-model_memory ≈ num_parameters × dtype_size
-```
-
-For example:
-- 7B parameters in FP16: ~14GB
-- 7B parameters in FP32: ~28GB
-- 7B parameters in INT8: ~7GB
-
-### Activation Memory
-
-Activation memory is typically smaller but varies with:
-- Batch size
-- Sequence length
-- Model architecture
-
-It's usually 10-30% of model weight memory during inference.

docs/configuration/stage_configs.md

@@ -41,7 +41,7 @@ stage_args:
       model_stage: thinker
       model_arch: Qwen2_5OmniForConditionalGeneration # The model implementation registered in model_executor/models/registry.py
       worker_cls: vllm_omni.worker.gpu_ar_worker.GPUARWorker # The specific worker used
-      scheduler_cls: vllm_omni.core.sched.omni_ar_scheduler.OmniARScheduler # The specific scehduler used
+      scheduler_cls: vllm_omni.core.sched.scheduler.OmniScheduler # The specific scehduler used
       gpu_memory_utilization: 0.8 # The gpu memory allocation for the stage within a single chip
       enforce_eager: true  # Now we only support eager mode
       trust_remote_code: true # Needed by huggingface config parsing
@@ -67,7 +67,7 @@ stage_args:
       model_stage: talker
       model_arch: Qwen2_5OmniForConditionalGeneration
       worker_cls: vllm_omni.worker.gpu_ar_worker.GPUARWorker
-      scheduler_cls: vllm_omni.core.sched.omni_ar_scheduler.OmniARScheduler
+      scheduler_cls: vllm_omni.core.sched.scheduler.OmniScheduler
       gpu_memory_utilization: 0.8
       enforce_eager: true
       trust_remote_code: true
@@ -92,8 +92,8 @@ stage_args:
     engine_args:
       model_stage: code2wav
       model_arch: Qwen2_5OmniForConditionalGeneration
-      worker_cls: vllm_omni.worker.gpu_generation_worker.GPUGenerationWorker
-      scheduler_cls: vllm_omni.core.sched.omni_generation_scheduler.OmniGenerationScheduler
+      worker_cls: vllm_omni.worker.gpu_diffusion_worker.GPUDiffusionWorker
+      scheduler_cls: vllm_omni.core.sched.diffusion_scheduler.DiffusionScheduler
       gpu_memory_utilization: 0.15
       enforce_eager: true
       trust_remote_code: true
@@ -171,11 +171,11 @@ The model architecture class name that is registered in `model_executor/models/r
 
 #### `engine_args.worker_cls`
 
-The specific worker class to use for this stage. This determines how the model computations are executed. Examples include `vllm_omni.worker.gpu_ar_worker.GPUARWorker` for autoregressive stages and `vllm_omni.worker.gpu_generation_worker.GPUGenerationWorker` for diffusion-based stages.
+The specific worker class to use for this stage. This determines how the model computations are executed. Examples include `vllm_omni.worker.gpu_ar_worker.GPUARWorker` for autoregressive stages and `vllm_omni.worker.gpu_diffusion_worker.GPUDiffusionWorker` for diffusion-based stages.
 
 #### `engine_args.scheduler_cls`
 
-The scheduler class to use for this stage. The scheduler manages request queuing, batching, and execution order. Examples include `vllm_omni.core.sched.omni_ar_scheduler.OmniARScheduler` for standard stages and `vllm_omni.core.sched.omni_generation_scheduler.OmniGenerationScheduler` for diffusion stages.
+The scheduler class to use for this stage. The scheduler manages request queuing, batching, and execution order. Examples include `vllm_omni.core.sched.scheduler.OmniScheduler` for standard stages and `vllm_omni.core.sched.diffusion_scheduler.DiffusionScheduler` for diffusion stages.
 
 #### `engine_args.gpu_memory_utilization`
 
@@ -183,9 +183,6 @@ The fraction of GPU memory to allocate for this stage within a single GPU chip.
 
 Default: `0.8`
 
-!!! tip "Memory Configuration Guide"
-    For detailed information on how to calculate memory requirements and properly configure `gpu_memory_utilization`, see the [GPU Memory Calculation and Configuration Guide](./gpu_memory_utilization.md).
-
 #### `engine_args.enforce_eager`
 
 Whether to enforce eager execution mode. When set to `true`, the engine will run in eager mode without using CUDA graphs or other compilation optimizations. Currently, vLLM-Omni only supports eager mode.

docs/configuration/stage_configs/qwen2_5_omni.yaml

@@ -60,8 +60,8 @@ stage_args:
     engine_args:
       model_stage: code2wav
       model_arch: Qwen2_5OmniForConditionalGeneration
-      worker_cls: vllm_omni.worker.gpu_generation_worker.GPUGenerationWorker
-      scheduler_cls: vllm_omni.core.sched.omni_generation_scheduler.OmniGenerationScheduler
+      worker_cls: vllm_omni.worker.gpu_diffusion_worker.GPUDiffusionWorker
+      scheduler_cls: vllm_omni.core.sched.diffusion_scheduler.DiffusionScheduler
       gpu_memory_utilization: 0.15
       enforce_eager: true
       trust_remote_code: true

docs/contributing/README.md

@@ -13,18 +13,23 @@ vLLM-Omni uses `uv` as the environment manager, to create and manage Python envi
 uv venv --python 3.12 --seed
 source .venv/bin/activate
 ```
+### Development Environment for vLLM
 
-### Development Environment for vLLM and vLLM-Omni
+vLLM-Omni is built on top of the stable release 0.11.0 of vLLM. You may install `vllm==0.11.0` directly or install the library from source if you need to check, modify or debug with source code of vLLM.
 
-vLLM-Omni is quickly evolving, please see the [installation guide](../getting_started/installation/README.md) for details. It's recommended to build from source to provide the latest development environment.
+### Development Environment for vLLM-Omni
+
+Install vLLM-Omni from source with development dependencies:
+
+```bash
+git clone https://github.com/vllm-project/vllm-omni.git
+cd vllm-omni
+uv pip install -e ".[dev]"
+```
 
 !!! tip
     vLLM-Omni is compatible with Python versions 3.10 to 3.12. However, we recommend developing with Python 3.12 to minimize the chance of your local environment clashing with our CI environment.
 
-### Adding a new model to vLLM-Omni
-
-Please check [model implementation](model/README.md) for how to add diffusion and omni-modality models to vLLM-Omni.
-
 ### Linting
 
 vLLM-Omni uses `pre-commit` to lint and format the codebase. See [pre-commit documentation](https://pre-commit.com/#usage) if `pre-commit` is new to you. Setting up `pre-commit` is as easy as:
@@ -116,7 +121,7 @@ Only specific types of PRs will be reviewed. The PR title is prefixed appropriat
 - `[Model]` for adding a new model or improving an existing model. Model name should appear in the title.
 - `[Frontend]` For changes on the vLLM-Omni frontend (e.g., OpenAI API server, `OmniLLM` class, etc.)
 - `[Kernel]` for changes affecting CUDA kernels or other compute kernels.
-- `[Core]` for changes in the core vLLM-Omni logic (e.g., `OmniProcessor`, `OmniARScheduler`, etc.)
+- `[Core]` for changes in the core vLLM-Omni logic (e.g., `OmniProcessor`, `OmniScheduler`, etc.)
 - `[Hardware][Vendor]` for hardware-specific changes. Vendor name should appear in the prefix, such as [Ascend] for Ascend NPUs.
 - `[Misc]` for PRs that do not fit the above categories. Please use this sparingly.
 

docs/contributing/ci/tests_markers.md

@@ -1,160 +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`       | Core model tests (run in each PR)                       |
-| `diffusion`        | Diffusion model tests                                   |
-| `omni`             | Omni model tests                                        |
-| `cache`            | Cache backend tests                                     |
-| `parallel`         | Parallelism/distributed tests                           |
-| `cpu`              | Tests that run on CPU                                   |
-| `gpu`              | Tests that run on GPU (auto-added)                      |
-| `cuda`             | Tests that run on CUDA (auto-added)                     |
-| `rocm`             | Tests that run on AMD/ROCm (auto-added)                 |
-| `npu`              | Tests that run on NPU/Ascend (auto-added)               |
-| `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                                         |
-
-For those markers shown as auto-added, they will be added by the `@hardware_test` decorator.
-
-### Example usage for markers
-
-```python
-from tests.utils 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/utils.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`, `npu`) and resource type (e.g., `L4`, `H100`, `MI325`, `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. **Runs each test in a new process**  
-   Automatically wraps the distributed test with a decorator (`@create_new_process_for_each_test`) to ensure isolation and compatibility with multi-process hardware backends.
-
-6. **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", "npu": "A2"},
-        num_cards={"cuda": 2, "rocm": 2, "npu": 2},
-    )
-    ```
-    or
-    ```python
-    @hardware_test(
-        res={"cuda": "L4", "rocm": "MI325", "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
-- `hardware_test` automatically applies `@create_new_process_for_each_test` for distributed tests.
-- 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"`
-
-## 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/utils.py`:
-   ```python
-   # In vllm-omni/tests/utils.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_test` to recognize your new platform**:
-    In the relevant place (see the `hardware_test` implementation), add:
-    ```python
-    if platform == "tpu":
-        marks = tpu_marks(res=resource, num_cards=cards)
-    ```
-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_test`  
-- You're done: tests decorated with `@hardware_test` using your platform now automatically get the correct markers, distribution, and isolation!
-
-See code in `vllm-omni/tests/utils.py` for existing examples (`cuda_marks`, `rocm_marks`, `npu_marks`).

docs/contributing/ci/tests_style.md

@@ -1,280 +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.
-
-## Test Types
-
-### 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)
-
-**Example:** The test file for `vllm_omni/entrypoints/omni_llm.py` should be located at `tests/entrypoints/test_omni_llm.py`.
-
-## Test Directory Structure
-
-The ideal directory structure mirrors the source code organization:
-
-```
-vllm_omni/                          tests/
-├── config/                    →    ├── config/
-│   └── model.py                    │   └── test_model.py
-│
-├── core/                      →    ├── core/
-│   └── sched/                      │   └── sched/                    # Maps to core/sched/
-│       ├── omni_ar_scheduler.py    │       ├── test_omni_ar_scheduler.py
-│       ├── omni_generation_scheduler.py │  ├── test_omni_generation_scheduler.py
-│       └── output.py               │       └── test_output.py
-│
-├── diffusion/                 →    ├── diffusion/
-│   ├── diffusion_engine.py         │   ├── test_diffusion_engine.py
-│   ├── omni_diffusion.py           │   ├── test_omni_diffusion.py
-│   ├── attention/                  │   ├── attention/                # Maps to diffusion/attention/
-│   │   └── backends/               │   │   └── test_*.py
-│   ├── models/                     │   ├── models/                   # Maps to diffusion/models/
-│   │   ├── qwen_image/             │   │   ├── qwen_image/
-│   │   │   └── ...                 │   │   │   └── test_*.py
-│   │   └── z_image/                │   │   └── z_image/
-│   │       └── ...                 │   │       └── test_*.py
-│   └── worker/                     │   └── worker/                   # Maps to diffusion/worker/
-│       └── ...                     │       └── test_*.py
-│
-├── distributed/               →    ├── distributed/
-│   └── ...                         │   └── test_*.py
-│
-├── engine/                    →    ├── engine/
-│   ├── processor.py                │   ├── test_processor.py
-│   └── output_processor.py         │   └── test_output_processor.py
-│
-├── entrypoints/               →    ├── entrypoints/
-│   ├── omni_llm.py                 │   ├── test_omni_llm.py          # UT: OmniLLM core logic (mocked)
-│   ├── omni_stage.py               │   ├── test_omni_stage.py         # UT: OmniStage logic
-│   ├── omni.py                     │   ├── test_omni.py               # E2E: Omni class (offline inference)
-│   ├── async_omni.py               │   ├── test_async_omni.py         # E2E: AsyncOmni class
-│   ├── cli/                        │   ├── cli/                       # Maps to entrypoints/cli/
-│   │   └── ...                     │   │   └── test_*.py
-│   └── openai/                     │   └── openai/                     # Maps to entrypoints/openai/
-│       ├── api_server.py           │       ├── test_api_server.py     # E2E: API server (online serving)
-│       └── serving_chat.py         │       └── test_serving_chat.py
-│
-├── inputs/                    →    ├── inputs/
-│   ├── data.py                     │   ├── test_data.py
-│   ├── parse.py                    │   ├── test_parse.py
-│   └── preprocess.py               │   └── test_preprocess.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_qwen2_5_omni_thinker.py  # UT
-│   │   │   ├── qwen2_5_omni_talker.py │ │   │   ├── test_qwen2_5_omni_talker.py  # UT
-│   │   │   └── qwen2_5_omni_token2wav.py │ │   │   └── test_qwen2_5_omni_token2wav.py  # UT
-│   │   └── qwen3_omni/             │   │   └── qwen3_omni/
-│   │       └── ...                 │   │       └── test_*.py
-│   ├── stage_configs/              │   └── stage_configs/             # Configuration tests (if needed)
-│   │   └── ...                     │       └── test_*.py
-│   └── stage_input_processors/     │   └── stage_input_processors/
-│       └── ...                     │       └── test_*.py
-│
-├── sample/                    →    ├── sample/
-│   └── ...                         │   └── test_*.py
-│
-├── utils/                     →    ├── utils/
-│   └── platform_utils.py           │   └── test_platform_utils.py
-│
-├── worker/                    →    ├── worker/
-    ├── gpu_ar_worker.py            │   ├── test_gpu_ar_worker.py
-    ├── gpu_generation_worker.py    │   ├── test_gpu_generation_worker.py
-    ├── gpu_model_runner.py         │   ├── test_gpu_model_runner.py
-    └── npu/                        │   └── npu/                       # Maps to worker/npu/
-        └── ...                     │       └── test_*.py
-│
-└── e2e/                       →    ├── e2e/                # End-to-end scenarios (no 1:1 source mirror)
-                                    ├── online_serving/       # Full-stack online serving flows
-                                    │   └── (empty for now)
-                                    └── offline_inference/    # Full offline inference flows
-                                        ├── test_qwen2_5_omni.py     # Moved from multi_stages/
-                                        ├── test_qwen3_omni.py       # Moved from multi_stages_h100/
-                                        ├── test_t2i_model.py  # Moved from single_stage/
-                                        └── stage_configs/           # Shared stage configs
-                                            ├── qwen2_5_omni_ci.yaml
-                                            └── qwen3_omni_ci.yaml
-```
-
-
-
-### Naming Conventions
-
-- **Unit Tests**: Use `test_<module_name>.py` format. Example: `omni_llm.py` → `test_omni_llm.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`
-
-### 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
-
-```python
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-"""
-Online E2E smoke test for an omni model (video,text,audio → audio).
-"""
-from pathlib import Path
-
-import pytest
-import openai
-
-from tests.utils import hardware_test
-
-# 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
-test_params = [(model, stage_config) for model in models for stage_config in stage_configs]
-
-#OmniServer，Used to start the vllm-omni server
-class OmniServer:
-    xxx
-
-
-@pytest.fixture
-def omni_server(request):
-    model, stage_config_path = request.param
-    with OmniServer(model, ["--stage-configs-path", stage_config_path]) as server:
-        yield server
-
-
-#handle request message
-@pytest.fixture(scope="session")
-def base64_encoded_video() -> str:
-    xxx
-
-@pytest.fixture(scope="session")
-def dummy_messages_from_video_data(video_data_url: str, content_text: str) -> str:
-    xxx
-
-@pytest.mark.core_model
-@pytest.mark.omni
-@hardware_test(
-    res={"cuda": "L4", "rocm": "MI325", "npu": "A2"},
-    num_cards={"cuda": 2, "rocm": 2, "npu": 4},
-)
-@pytest.mark.parametrize("omni_server", test_params, indirect=True)
-def test_video_to_audio(
-    client: openai.OpenAI,
-    omni_server,
-    base64_encoded_video: str,
-) -> None:
-    #set message
-    video_data_url = f"data:video/mp4;base64, {base64_encoded_video}"
-    messages = dummy_messages_from_video_data(video_data_url)
-
-    #send request
-    chat_completion = client.chat.completions.create(
-        model=omni_server.model,
-        messages=messages,
-    )
-
-    #verify text output
-    text_choice = chat_completion.choices[0]
-    assert text_choice.finish_reason == "length"
-
-    #verify audio output
-    audio_choice = chat_completion.choices[1]
-    audio_message = audio_choice.message
-    if hasattr(audio_message, "audio") and audio_message.audio:
-        assert audio_message.audio.data is not None
-        assert len(audio_message.audio.data) > 0
-```
-
-#### 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.utils 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
-```
-
-## 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 above.
-3. **All test functions have appropriate pytest markers**
-4. For tests that need run in CI, please ensure the test is configured under the `./buildkite/` folder.

docs/contributing/model/README.md

@@ -1,15 +1,2 @@
 # Adding a New Model
-
-This section provides comprehensive guidance on how to add a new model to vLLM-Omni.
-
-## Documentation
-
-- **[Adding an Omni-Modality Model](adding_omni_model.md)**: Complete step-by-step guide using Qwen3-Omni as an example.
-
-- **[Adding a Diffusion Model](adding_diffusion_model.md)**: Complete step-by-step guide using Qwen/Qwen-Image-Edit as an example.
-
-
-
-## Quick Start
-
-For a quick reference, see the [Adding a New Multi-Stage Model Guide](adding_omni_model.md) and [Adding a New Diffusion Model Guide](adding_diffusion_model.md).
+Stay tuned for guidance on how to add a new model on vLLM-Omni!

docs/contributing/model/adding_diffusion_model.md

@@ -1,147 +0,0 @@
-# Adding a Diffusion Model
-This guide walks through the process of adding a new Diffusion model to vLLM-Omni, using Qwen/Qwen-Image-Edit as a comprehensive example.
-
-# Table of Contents
-1. [Overview](#overview)
-2. [Directory Structure](#directory-structure)
-3. [Step-by-Step Implementation](#step-by-step-implementation)
-4. [Testing](#testing)
-5. [Adding a Model Recipe](#adding-a-model-recipe)
-
-
-# Overview
-When add a new diffusion model into vLLM-Omni, additional adaptation work is required due to the following reasons:
-
-+ New model must follow the framework’s parameter passing mechanisms and inference flow.
-
-+ Replacing the model’s default implementations with optimized modules, which is necessary to achieve the better performance.
-
-The diffusion execution flow as follow:
-<p align="center">
-  <picture>
-    <source media="(prefers-color-scheme: dark)" src="https://raw.githubusercontent.com/vllm-project/vllm-omni/refs/heads/main/docs/source/architecture/vllm-omni-diffusion-flow.png">
-    <img alt="Diffusion Flow" src="https://raw.githubusercontent.com/vllm-project/vllm-omni/refs/heads/main/docs/source/architecture/vllm-omni-diffusion-flow.png" width=55%>
-  </picture>
-</p>
-
-
-# Directory Structure
-File Structure for Adding a New Diffusion Model
-
-```
-vllm_omni/
-└── examples/
-    └──offline_inference
-        └── example script                # reuse existing if possible (e.g., image_edit.py)
-    └──online_serving
-        └── example script
-└── diffusion/
-    └── registry.py                       # Registry work
-    ├── request.py                        # Request Info
-    └── models/your_model_name/           # Model directory (e.g., qwen_image)
-        └── pipeline_xxx.py               # Model implementation (e.g., pipeline_qwen_image_edit.py)
-```
-
-# Step-by-step-implementation
-## Step 1: Model Implementation
-The diffusion pipeline’s implementation follows **HuggingFace Diffusers**, and components that do not need modification can be imported directly.
-### 1.1 Define the Pipeline Class
-Define the pipeline class, e.g., `QwenImageEditPipeline`, and initialize all required submodules, either from HuggingFace `diffusers` or custom implementations. In `QwenImageEditPipeline`, only `QwenImageTransformer2DModel` is re-implemented to support optimizations such as Ulysses-SP. When adding new models in the future, you can either reuse this re-implemented `QwenImageTransformer2DModel` or extend it as needed.
-
-### 1.2 Pre-Processing and Post-Processing Extraction
-Extract the pre-processing and post-processing logic from the pipeline class to follow vLLM-Omni’s execution flow. For Qwen-Image-Edit:
-```python
-def get_qwen_image_edit_pre_process_func(
-    od_config: OmniDiffusionConfig,
-):
-    """
-    Define a pre-processing function that resizes input images and
-    pre-process for subsequent inference.
-    """
-```
-
-```python
-def get_qwen_image_edit_post_process_func(
-    od_config: OmniDiffusionConfig,
-):
-    """
-    Defines a post-processing function that post-process images.
-    """
-```
-
-### 1.3 Define the forward function
-The forward function of `QwenImageEditPipeline` follows the HuggingFace `diffusers` design for the most part. The key differences are:
-+ As described in the overview, arguments are passed through `OnniDiffusionRequest`, so we need to get user parameters from it accordingly.
-```python
-prompt = req.prompt if req.prompt is not None else prompt
-```
-+ pre/post-processing are handled by the framework elsewhere, so skip them.
-
-## Step 2: Extend OmniDiffusionRequest Fields
-User-provided inputs are ultimately passed to the model’s forward method through OmniDiffusionRequest, so we add the required fields here to support the new model.
-```python
-prompt: str | list[str] | None = None
-negative_prompt: str | list[str] | None = None
-...
-```
-
-## Step 3: Registry
-+ registry diffusion model in registry.py
-```python
-_DIFFUSION_MODELS = {
-    # arch:(mod_folder, mod_relname, cls_name)
-    ...
-    "QwenImageEditPipeline": (
-        "qwen_image",
-        "pipeline_qwen_image_edit",
-        "QwenImageEditPipeline",
-    ),
-    ...
-}
-```
-+ registry pre-process get function
-```python
-_DIFFUSION_PRE_PROCESS_FUNCS = {
-    # arch: pre_process_func
-    ...
-    "QwenImageEditPipeline": "get_qwen_image_edit_pre_process_func",
-    ...
-}
-```
-
-+ registry post-process get function
-```python
-_DIFFUSION_POST_PROCESS_FUNCS = {
-    # arch: post_process_func
-    ...
-    "QwenImageEditPipeline": "get_qwen_image_edit_post_process_func",
-    ...
-}
-```
-
-## Step 4: Add an Example Script
-For each newly integrated model, we need to provide examples script under the examples/ to demonstrate how to initialize the pipeline with Omni, pass in user inputs, and generate outputs.
-Key point for writing the example:
-
-+ Use the Omni entrypoint to load the model and construct the pipeline.
-
-+ Show how to format user inputs and pass them via omni.generate(...).
-
-+ Demonstrate the common runtime arguments, such as:
-
-    + model path or model name
-
-    + input image(s) or prompt text
-
-    + key diffusion parameters (e.g., inference steps, guidance scale)
-
-    + optional acceleration backends (e.g., Cache-DiT, TeaCache)
-
-+ Save or display the generated results so users can validate the integration.
-
-# Testing
-For comprehensive testing guidelines, please refer to the [Test File Structure and Style Guide](../ci/tests_style.md).
-
-
-## Adding a Model Recipe
-After implementing and testing your model, please add a model recipe to the [vllm-project/recipes](https://github.com/vllm-project/recipes) repository. This helps other users understand how to use your model with vLLM-Omni.

docs/contributing/model/adding_omni_model.md

@@ -1,633 +0,0 @@
-# Adding an Omni-Modality Model
-
-This guide walks through the process of adding a new multi-stage model to vLLM-Omni, using **Qwen3-Omni** as a comprehensive example. Qwen3-Omni is a multi-stage omni-modality model that demonstrates the full capabilities of vLLM-Omni's architecture.
-
-## Table of Contents
-
-1. [Overview](#overview)
-2. [Directory Structure](#directory-structure)
-3. [Step-by-Step Implementation](#step-by-step-implementation)
-4. [Key Components](#key-components)
-5. [Model Registration](#model-registration)
-6. [Stage Configuration](#stage-configuration)
-7. [Stage Input Processors](#stage-input-processors)
-8. [Testing](#testing)
-9. [Adding a Model Recipe](#adding-a-model-recipe)
-10. [Summary](#summary)
-
-## Overview
-
-vLLM-Omni supports multi-stage model architectures where different stages can run on different devices and process different modalities. The Qwen3-Omni model exemplifies this with three stages:
-
-1. **Thinker Stage**: Multimodal understanding (text + audio + video) → text generation
-2. **Talker Stage**: Text embeddings → RVQ codec codes
-3. **Code2Wav Stage**: RVQ codes → audio waveform
-
-Each stage is implemented as a separate model class that can be configured independently.
-
-## Directory Structure
-
-When adding a new model, you'll need to create the following structure:
-
-```
-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
-    ├── 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)
-    └── ... maybe other stage implementations
-
-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
-```
-
-## Step-by-Step Implementation
-
-### Step 1: Create the Model Directory
-
-Create a new directory under `vllm_omni/model_executor/models/`
-
-### Step 2: Implement Stage Components
-
-For Qwen3-Omni, we have three stage components:
-
-#### 2.1 Thinker Stage (`qwen3_omni_moe_thinker.py`)
-
-The thinker stage handles multimodal understanding. Key features:
-
-- Inherits from base Qwen3 MoE model in vLLM, using vLLM fused ops & page attn to accelerate
-- Implements multimodal processing interfaces
-- Handles audio, video, and image inputs
-- Generates text outputs
-
-```python
-from vllm.model_executor.models.interfaces import SupportsMultiModal, SupportsPP
-from vllm.model_executor.models.qwen3_moe import Qwen3MoeForCausalLM
-
-class Qwen3OmniMoeThinkerForConditionalGeneration(
-    Qwen3MoeForCausalLM,
-    SupportsMultiModal,
-    SupportsPP
-):
-    """Thinker stage: multimodal understanding → text generation."""
-
-    def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
-        # Initialize base model
-        # Set up multimodal processors
-        # Configure audio/video/image encoders
-        pass
-```
-
-#### 2.2 Talker Stage (`qwen3_omni_moe_talker.py`)
-
-The talker stage converts text embeddings to codec codes:
-
-```python
-class Qwen3OmniMoeTalkerForConditionalGeneration(
-    Qwen3MoeForCausalLM,
-    SupportsPP
-):
-    """Talker stage: text embeddings → RVQ codec codes."""
-
-    def __init__(self, vllm_config, talker_config, prefix):
-        # Initialize base model
-        # Replace LM head with codec head
-        # Set up text projection from thinker
-        pass
-```
-
-#### 2.3 Code2Wav Stage (`qwen3_omni_code2wav.py`)
-
-The code2wav stage generates audio waveforms:
-
-```python
-class Qwen3OmniMoeCode2Wav(nn.Module):
-    """Code2Wav stage: RVQ codes → audio waveform."""
-
-    def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
-        # Initialize audio decoder
-        # Set up codec processing
-        pass
-```
-
-### Step 3: Implement the Unified Model Class
-
-The main model class (`qwen3_omni.py`) orchestrates all stages:
-
-```python
-@MULTIMODAL_REGISTRY.register_processor(
-    Qwen3OmniMoeThinkerMultiModalProcessor,
-    info=Qwen3OmniMoeThinkerProcessingInfo,
-    dummy_inputs=Qwen3OmniMoeThinkerDummyInputsBuilder,
-)
-class Qwen3OmniMoeForConditionalGeneration(
-    nn.Module, SupportsMultiModal, SupportsPP, Qwen3OmniMoeConditionalGenerationMixin
-):
-    """
-    Unified Qwen3 Omni MoE model combining thinker, talker, and code2wav.
-
-    Architecture:
-    - Thinker: Multimodal understanding (text + audio + video) → text generation
-    - Talker: Text embeddings → RVQ codec codes
-    - Code2Wav: RVQ codes → audio waveform
-
-    Usage:
-        Set `model_stage` in vllm_config to one of: "thinker", "talker", "code2wav"
-    """
-
-    def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
-        super().__init__()
-        self.have_multimodal_outputs = True
-        config: Qwen3OmniMoeConfig = vllm_config.model_config.hf_config
-
-        # Determine which stage to initialize
-        self.model_stage = vllm_config.model_config.model_stage
-
-        if self.model_stage == "thinker":
-            # Initialize thinker model
-            thinker_vllm_config = vllm_config.with_hf_config(
-                config.thinker_config,
-                architectures=["Qwen3OmniMoeThinkerForConditionalGeneration"]
-            )
-            self.thinker = init_vllm_registered_model(
-                vllm_config=thinker_vllm_config,
-                prefix=maybe_prefix(prefix, "thinker"),
-                hf_config=config.thinker_config,
-                architectures=["Qwen3OmniMoeThinkerForConditionalGeneration"],
-            )
-            self.model = self.thinker
-
-        elif self.model_stage == "talker":
-            # Initialize talker model
-            talker_vllm_config = vllm_config.with_hf_config(
-                config.talker_config,
-                architectures=["Qwen3OmniMoeTalkerForConditionalGeneration"]
-            )
-            self.talker = init_vllm_registered_model(
-                vllm_config=talker_vllm_config,
-                prefix=maybe_prefix(prefix, "talker"),
-                hf_config=config.talker_config,
-                architectures=["Qwen3OmniMoeTalkerForConditionalGeneration"],
-            )
-            self.model = self.talker
-
-        elif self.model_stage == "code2wav":
-            # Initialize code2wav model
-            code2wav_vllm_config = vllm_config.with_hf_config(
-                config.code2wav_config,
-                architectures=["Qwen3OmniMoeCode2Wav"]
-            )
-            self.code2wav = init_vllm_registered_model(
-                vllm_config=code2wav_vllm_config,
-                prefix=maybe_prefix(prefix, "code2wav"),
-                hf_config=config.code2wav_config,
-                architectures=["Qwen3OmniMoeCode2Wav"],
-            )
-            self.model = self.code2wav
-        else:
-            raise ValueError(
-                f"Invalid model_stage: {self.model_stage}. "
-                f"Must be one of: 'thinker', 'talker', 'code2wav'"
-            )
-```
-
-#### Key Methods to Implement
-
-1. **`forward()`**: Handles the forward pass for each stage
-2. **`embed_input_ids()`**: Embeds input token IDs
-3. **`embed_multimodal()`**: Processes multimodal inputs (if applicable)
-4. **`compute_logits()`**: Computes logits from hidden states
-5. **`load_weights()`**: Loads model weights with proper prefixing of different stages
-
-### Step 4: Create `__init__.py`
-
-Export the main model class:
-
-```python
-# vllm_omni/model_executor/models/qwen3_omni/__init__.py
-from .qwen3_omni import Qwen3OmniMoeForConditionalGeneration
-
-__all__ = ["Qwen3OmniMoeForConditionalGeneration"]
-```
-
-## Key Components
-
-### 1. Model Interfaces
-
-Your model should implement the appropriate interfaces:
-
-- **`SupportsMultiModal`**: For models that process multimodal inputs
-- **`SupportsPP`**: For models that support pipeline parallelism
-- **`SupportsMRoPE`**: For models using multi-dimensional RoPE (if applicable)
-
-### 2. Multimodal Registration
-
-If your model processes multimodal inputs, register it with the multimodal registry:
-
-```python
-@MULTIMODAL_REGISTRY.register_processor(
-    YourMultiModalProcessor,
-    info=YourProcessingInfo,
-    dummy_inputs=YourDummyInputsBuilder,
-)
-class YourModel(nn.Module, SupportsMultiModal):
-    pass
-```
-
-### 3. Weight Loading
-
-Implement `load_weights()` to handle weight loading with proper prefixing:
-
-```python
-def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
-    """Load weights for all components of the omni model."""
-    loaded_weights = set()
-    thinker_weights = []
-    talker_weights = []
-    code2wav_weights = []
-
-    # Separate weights by component
-    for k, v in weights:
-        if k.startswith("thinker."):
-            thinker_weights.append((k, v))
-        elif k.startswith("talker."):
-            talker_weights.append((k, v))
-        elif k.startswith("code2wav."):
-            code2wav_weights.append((k, v))
-
-    # Load each component's weights
-    if self.thinker and thinker_weights:
-        thinker_loaded = self.thinker.load_weights(thinker_weights)
-        thinker_loaded = add_prefix_to_loaded_weights(thinker_loaded, "thinker")
-        loaded_weights.update(thinker_loaded)
-
-    # Similar for talker and code2wav...
-
-    return loaded_weights
-```
-
-### 4. Output Format
-
-Use `OmniOutput` for stage outputs:
-
-```python
-from vllm_omni.model_executor.models.output_templates import OmniOutput
-
-# In forward method
-return OmniOutput(
-    text_hidden_states=hidden_states,
-    multimodal_outputs={"additional_data": data},
-    next_token_id=next_token_id,
-)
-```
-
-## Model Registration
-
-Register your model in `vllm_omni/model_executor/models/registry.py`:
-
-```python
-_OMNI_MODELS = {
-    # ... existing models ...
-
-    # Your new model
-    "YourModelForConditionalGeneration": (
-        "your_model_name",        # Module folder name
-        "your_model",             # Module file name (without .py)
-        "YourModelForConditionalGeneration",  # Class name
-    ),
-    "YourModelThinkerForConditionalGeneration": (
-        "your_model_name",
-        "your_model_thinker",
-        "YourModelThinkerForConditionalGeneration",
-    ),
-    # ... other stages ...
-}
-```
-
-The registry uses lazy loading, so the model class is imported only when needed.
-
-## Stage Configuration
-
-Create a YAML configuration file in `vllm_omni/model_executor/stage_configs/`. For a complete example, see the [Qwen3-Omni configuration file](gh-file:vllm_omni/model_executor/stage_configs/qwen3_omni_moe.yaml).
-
-### Key Configuration Fields
-
-- **`model_stage`**: Which stage to run ("thinker", "talker", "code2wav", etc.)
-- **`model_arch`**: The model architecture name (must match registry)
-- **`engine_input_source`**: List of stage IDs that provide input to this stage
-- **`custom_process_input_func`**: Function to process inputs from previous stages
-- **`final_output`**: Whether this stage produces the final output (True/False)
-- **`final_output_type`**: Type of final output ("text", "audio", "image", etc.)
-
-## Stage Input Processors
-
-Stage transitions are the mechanism by which outputs from one stage are converted into inputs for the next stage. This section explains where and how stage transitions occur.
-
-### Where Stage Transitions Are Called
-
-Stage transitions happen automatically in the orchestrator (`OmniLLM` class) during the generation loop. Here's the detailed flow:
-
-1. **Location**: `vllm_omni/entrypoints/omni_llm.py` in the `_run_generation()` method
-2. **Trigger**: When a stage completes processing and produces outputs
-3. **Execution Flow**:
-   ```python
-   # In omni_llm.py, _run_generation() method (around line 345-460)
-
-   # Main orchestrator loop polls each stage for completed requests
-   for stage_id, stage in enumerate(self.stage_list):
-       result = stage.try_collect()  # Get completed request
-       if result is None:
-           continue
-
-       # Store outputs from this stage
-       engine_outputs = _load(result, obj_key="engine_outputs", shm_key="engine_outputs_shm")
-       stage.set_engine_outputs(engine_outputs)
-
-       # Check if there's a next stage to forward to
-       next_stage_id = stage_id + 1
-       if next_stage_id < len(self.stage_list):
-           next_stage: OmniStage = self.stage_list[next_stage_id]
-
-           # THIS IS WHERE STAGE TRANSITION HAPPENS
-           next_inputs = next_stage.process_engine_inputs(
-               self.stage_list,
-               [request_id_to_prompt[req_id]]
-           )
-
-           # Submit to next stage
-           task = {
-               "type": OmniStageTaskType.GENERATE,
-               "request_id": req_id,
-               "engine_inputs": next_inputs[0],
-               "sampling_params": sampling_params_list[next_stage_id],
-           }
-           next_stage.submit(task)
-   ```
-
-### How Stage Transitions Work
-
-The stage transition process follows these steps:
-
-1. **Stage Completion**: When a stage finishes processing a request, it stores outputs via `stage.set_engine_outputs(engine_outputs)`
-
-2. **Transition Detection**: The orchestrator checks if there's a next stage and calls `process_engine_inputs()` on it
-
-3. **Input Processing**: The `process_engine_inputs()` method in `OmniStage` (`omni_stage.py`) handles the transition:
-   ```python
-   def process_engine_inputs(
-       self, stage_list: list[Any], prompt: OmniTokensPrompt | TextPrompt = None
-   ) -> list[OmniTokensPrompt | TextPrompt]:
-       """Process engine inputs for this stage from upstream stage outputs."""
-
-       if self.custom_process_input_func is None:
-           # Default behavior: pass token IDs directly
-           # Extract outputs from source stage
-           source_stage_id = self.engine_input_source[0]
-           source_outputs = stage_list[source_stage_id].engine_outputs
-           # ... create OmniTokensPrompt from token_ids ...
-       else:
-           # Custom transition function (YOUR CODE HERE)
-           return self.custom_process_input_func(
-               stage_list,
-               self.engine_input_source,
-               prompt,
-               self.requires_multimodal_data
-           )
-   ```
-   - If `custom_process_input_func` is configured, it calls that function
-   - Otherwise, it uses default behavior (passing token IDs directly)
-
-4. **Custom Function Execution**: Your custom function receives:
-   - `stage_list`: List of all stage objects (to access upstream stage outputs)
-   - `engine_input_source`: List of source stage IDs (e.g., `[0]` for stage 0)
-   - `prompt`: Original prompt data (for preserving multimodal data)
-   - `requires_multimodal_data`: Whether multimodal data is required
-
-5. **Output Format**: The function must return a list of `OmniTokensPrompt` objects ready for the next stage
-
-### Data Structures in Stage Transitions
-
-Understanding the data structures is crucial for implementing stage transitions:
-
-**Input to your function:**
-- `stage_list[source_stage_id].engine_outputs`: List of `EngineCoreOutput` objects
-  - Each contains `outputs`: List of `RequestOutput` objects
-  - Each `RequestOutput` has:
-    - `token_ids`: Generated token IDs
-    - `multimodal_output`: Dict with keys like `"code_predictor_codes"`, etc.
-      - These are the hidden states or intermediate outputs from the model's forward pass
-    - `prompt_token_ids`: Original prompt token IDs
-
-**Output from your function:**
-- Must return `list[OmniTokensPrompt]` where each `OmniTokensPrompt` contains:
-  - `prompt_token_ids`: List[int] - Token IDs for the next stage
-  - `additional_information`: Dict[str, Any] - Optional metadata (e.g., embeddings, hidden states)
-  - `multi_modal_data`: Optional multimodal data if needed
-
-### How Model Outputs Are Stored
-
-The model's `forward()` method returns an `OmniOutput` object that contains:
-- `text_hidden_states`: Final hidden states for text generation
-- `multimodal_outputs`: Dict containing intermediate outputs
-
-These outputs are captured during the forward pass and stored in `multimodal_output` with specific keys:
-
-```python
-# In your model's forward() method (e.g., qwen3_omni.py)
-def forward(self, ...):
-    # ... processing ...
-
-    # For thinker stage: capture embeddings and hidden states
-    multimodal_outputs = {
-        "0": captured_embeddings,      # Layer 0 embeddings
-        "24": captured_hidden_states,  # Layer 24 hidden states
-        "tts_bos_embed": tts_bos_embed,
-        "tts_eos_embed": tts_eos_embed,
-        # ... other intermediate outputs ...
-    }
-
-    return OmniOutput(
-        text_hidden_states=hidden_states,
-        multimodal_outputs=multimodal_outputs,
-    )
-```
-
-These keys are then accessible in your stage transition function:
-```python
-# In stage_input_processors/qwen3_omni.py
-thinker_embeddings = output.multimodal_output["0"]  # Access by key
-thinker_hidden_states = output.multimodal_output["24"]
-```
-
-### Key Points
-
-1. **Accessing Upstream Outputs**: Use `stage_list[source_stage_id].engine_outputs` to get outputs from the source stage
-2. **Extracting Data**: Access `output.multimodal_output[key]` to get specific hidden states or intermediate results
-   - Keys are defined by your model's `forward()` method when it creates `multimodal_outputs`
-3. **Device Management**: Move tensors to appropriate devices (CPU for serialization, GPU for processing)
-4. **Shape Transformations**: Reshape tensors as needed for the next stage (e.g., flattening codec codes)
-5. **Batch Handling**: Process each request in the batch separately and return a list
-
-### Complete Flow Diagram
-
-<p align="center">
-  <picture>
-    <source media="(prefers-color-scheme: dark)" src="https://raw.githubusercontent.com/vllm-project/vllm-omni/refs/heads/main/docs/source/architecture/vllm-omni-dataflow-between-stages.png">
-    <img alt="Data Flow between stages" src="https://raw.githubusercontent.com/vllm-project/vllm-omni/refs/heads/main/docs/source/architecture/vllm-omni-dataflow-between-stages.png" width=55%>
-  </picture>
-</p>
-
-### Implementation Example
-
-Create stage transition processors in `vllm_omni/model_executor/stage_input_processors/your_model_name.py`:
-
-```python
-# qwen3_omni.py
-
-def thinker2talker(
-    stage_list: list[Any],
-    engine_input_source: list[int],
-    prompt: OmniTokensPrompt | TextPrompt | None = None,
-    requires_multimodal_data: bool = False,
-) -> list[OmniTokensPrompt]:
-    """
-    Process thinker outputs to create talker inputs.
-
-    Args:
-        stage_list: List of stage objects
-        engine_input_source: Source stage IDs (typically [0] for thinker)
-        prompt: Original prompt data
-
-    Returns:
-        List of OmniTokensPrompt for talker stage
-    """
-    source_stage_id = engine_input_source[0]
-    thinker_outputs = stage_list[source_stage_id].engine_outputs
-    talker_inputs = []
-
-    for thinker_output in thinker_outputs:
-        output = thinker_output.outputs[0]
-        # Extract thinker embeddings and hidden states
-        thinker_embeddings = output.multimodal_output["0"].float().clone().detach().cuda()
-        thinker_hidden_states = output.multimodal_output["24"].float().clone().detach().cuda()
-
-        info = {
-            "thinker_embeddings": thinker_embeddings,
-            "thinker_hidden_states": thinker_hidden_states,
-            "thinker_sequences": thinker_output.prompt_token_ids + output.token_ids,
-            "thinker_input_ids": thinker_output.prompt_token_ids,
-        }
-
-        talker_inputs.append(
-            OmniTokensPrompt(
-                prompt_token_ids=[0] * computed_length,
-                additional_information=info,
-                multi_modal_data=None,
-            )
-        )
-
-    return talker_inputs
-
-
-def talker2code2wav(
-    stage_list: list[Any],
-    engine_input_source: list[int],
-    prompt: OmniTokensPrompt | TextPrompt | None = None,
-    requires_multimodal_data: bool = False,
-) -> list[OmniTokensPrompt]:
-    """
-    Process talker outputs to create code2wav inputs.
-    """
-    source_stage_id = engine_input_source[0]
-    talker_outputs = stage_list[source_stage_id].engine_outputs
-    code2wav_inputs = []
-
-    for talker_output in talker_outputs:
-        output = talker_output.outputs[0]
-        # Extract codec codes
-        codec_codes = (
-            output.multimodal_output["code_predictor_codes"]
-            .to(torch.long)
-            .transpose(0, 1)
-            .cpu()
-            .to(torch.long)
-            .reshape(-1)
-            .tolist()
-        )
-
-        code2wav_inputs.append(
-            OmniTokensPrompt(
-                prompt_token_ids=codec_codes,
-                multi_modal_data=None,
-            )
-        )
-
-    return code2wav_inputs
-```
-
-## Testing
-
-For comprehensive testing guidelines, please refer to the [Test File Structure and Style Guide](../ci/tests_style.md).
-
-## Adding a Model Recipe
-
-After implementing and testing your model, please add a model recipe to the [vllm-project/recipes](https://github.com/vllm-project/recipes) repository. This helps other users understand how to use your model with vLLM-Omni.
-
-### What to Include
-
-Your recipe should include:
-
-1. **Model Overview**: Brief description of the model and its capabilities
-2. **Installation Instructions**: Step-by-step setup instructions including:
-   - Installing vllm-omni and dependencies
-   - Installing any additional required packages (e.g., xformers, diffusers)
-   - Any version requirements
-3. **Usage Examples**: Command-line examples demonstrating how to run the model
-4. **Configuration Details**: Important configuration parameters and their meanings
-
-### Example
-
-For reference, see the [LongCat recipe example](https://github.com/vllm-project/recipes/pull/179) which demonstrates the expected format and structure.
-
-### Recipe Location
-
-Create your recipe file in the appropriate directory structure:
-- For organization-specific models: `OrganizationName/ModelName.md`
-- For general models: `ModelName.md`
-
-The recipe should be a Markdown file that provides clear, reproducible instructions for users to get started with your model.
-
-## Summary
-
-Adding a new model to vLLM-Omni involves:
-
-1. **Create model directory structure** with stage implementations
-2. **Implement unified model class** that orchestrates stages
-3. **Register model** in `registry.py`
-4. **Create stage configuration** YAML file
-5. **Implement stage input processors** for stage transitions
-6. **Write tests** to verify functionality
-7. **Add model recipe** to the [vllm-project/recipes](https://github.com/vllm-project/recipes) repository (see [Adding a Model Recipe](#adding-a-model-recipe) section)
-
-### Qwen3-Omni Reference Files
-
-For a complete reference implementation, see:
-
-- **Main model**: `vllm_omni/model_executor/models/qwen3_omni/qwen3_omni.py`
-- **Thinker**: `vllm_omni/model_executor/models/qwen3_omni/qwen3_omni_moe_thinker.py`
-- **Talker**: `vllm_omni/model_executor/models/qwen3_omni/qwen3_omni_moe_talker.py`
-- **Code2Wav**: `vllm_omni/model_executor/models/qwen3_omni/qwen3_omni_code2wav.py`
-- **Stage config**: `vllm_omni/model_executor/stage_configs/qwen3_omni_moe.yaml`
-- **Input processors**: `vllm_omni/model_executor/stage_input_processors/qwen3_omni.py`
-- **Registry**: `vllm_omni/model_executor/models/registry.py`
-- **Testing**: `vllm_omni/tests/e2e/offline_inference/test_qwen3_omni.py`
-
-For more information, see:
-- [Architecture Overview](../../design/architecture_overview.md)
-- [Supported Models](../../models/supported_models.md)
-- [Stage Configuration Guide](../../configuration/stage_configs.md)

docs/contributing/profiling.md

@@ -1,99 +0,0 @@
-# Profiling vLLM-Omni
-
-Performance Profiling Guidelines Profiling capabilities in vLLM-Omni are reserved for development and maintenance tasks aimed at temporal analysis of the codebase. Production use is **strongly discouraged**; enabling the profiler incurs a substantial overhead that negatively impacts inference latency.
-
-**Mechanism**: vLLM-Omni implements cross-stage profiling via the PyTorch Profiler. To accommodate the architecture—where stages operate as distinct engine instances in separate processes—the profiling interface supports both holistic capturing (all stages) and targeted capturing (specific stages).
-
-**1. Enabling the Profiler**
-
-Before running your script, you must set the ```VLLM_TORCH_PROFILER_DIR``` environment
-variable.
-
-```Bash
-export VLLM_TORCH_PROFILER_DIR=/path/to/save/traces
-```
-
-**Highly Recommended: Limit Profiling to a Single Iteration**  
-For most use cases (especially when profiling audio stages), you should limit the profiler to just **one iteration** to keep trace files small and readable.
-
-
-```bash
-export VLLM_PROFILER_MAX_ITERS=1
-```
-
-**2. Offline Inference**
-
-For offlinie processing using ```OmniLLM```, you can wrap your ```generate``` calls with ```start_profile``` and ```stop_profile()```.
-
-Basic Usage(All Stages)
-```Python
-from vllm_omni import OmniLLM
-
-omni_llm = OmniLLM.from_engine_args(engine_args)
-
-# Start profiling all active stages
-omni_llm.start_profile()
-
-outputs = omni_llm.generate(prompts, sampling_params)
-
-# Stop profiling and save traces
-omni_llm.stop_profile()
-```
-
-**Selective Stage Profiling**
-The profiler is default to function across all stages. But It is highly recommended to profile specific stages by passing the stages list, preventing from producing too large trace files:
-```python
-# Only profile Stage 1
-omni_llm.start_profile(stages=[1])
-```
-
-```python
-# Stage 0 (Thinker) and Stage 2 (Audio Decoder) for qwen omni
-omni_llm.start_profile(stages=[0, 2])
-```
-
-**Examples**:
-
-1. **Qwen-omni 2.5**:  [https://github.com/vllm-project/vllm-omni/blob/main/examples/offline_inference/qwen2_5_omni/end2end.py](https://github.com/vllm-project/vllm-omni/blob/main/examples/offline_inference/qwen2_5_omni/end2end.py)
-
-2. **Qwen-omni 3.0**:   [https://github.com/vllm-project/vllm-omni/blob/main/examples/offline_inference/qwen3_omni/end2end.py](https://github.com/vllm-project/vllm-omni/blob/main/examples/offline_inference/qwen3_omni/end2end.py)
-
-**3. Online Inference(Async)**
-
-For online serving using AsyncOmni, the methods are asynchronous. This allows you to toggle profiling dynamically without restarting the server.
-
-```python
-from vllm_omni import AsyncOmni
-
-# Inside an async function:
-async_omni = AsyncOmni.from_engine_args(engine_args)
-
-await async_omni.start_profile()
-
-async for output in async_omni.generate(prompt, sampling_params, request_id):
-    # Process outputs...
-    pass
-
-await async_omni.stop_profile()
-```
-
-**4. Analyzing Omni Traces**
-
-After ``stop_profile()`` completes (and the file write wait time has passed), the directory specified in ```VLLM_TORCH_PROFILER_DIR``` will contain the trace files.
-
-```
-Output/
-│── ...rank-0.pt.trace.json.gz   # GPU 0 trace (TP=2 Example)
-│── ...rank-1.pt.trace.json.gz   # GPU 1 trace (TP=2 Example)
-│       # Load these into Perfetto to visualize synchronization
-│
-│── profiler_out_.txt            # Summary tables (CPU/CUDA time %)
-```
-
-**Viewing Tools:**
-     - [Perfetto](https://ui.perfetto.dev/): (Recommended): Best for handling large audio trace files.
-     - ```chrome://tracing```: Good for smaller text-only traces.
-
-
-**Note**: vLLM-Omni reuses the PyTorch Profiler infrastructure from vLLM.  
-For more advanced configuration options (memory profiling, custom activities, etc.), see the official vLLM profiler documentation:  [vLLM Profiling Guide](https://docs.vllm.ai/en/latest/dev/profiling.html)

docs/design/architecture_overview.md

@@ -28,8 +28,8 @@ According to analysis for current popular open-source models, most of them have
 
 <p align="center">
   <picture>
-    <source media="(prefers-color-scheme: dark)" src="https://raw.githubusercontent.com/vllm-project/vllm-omni/refs/heads/main/docs/source/architecture/dit-main-architecture.png">
-    <img alt="Qwen-Image" src="https://raw.githubusercontent.com/vllm-project/vllm-omni/refs/heads/main/docs/source/architecture/dit-main-architecture.png" width=30%>
+    <source media="(prefers-color-scheme: dark)" src="https://raw.githubusercontent.com/vllm-project/vllm-omni/refs/heads/main/docs/source/architecture/ar-main-architecture.png">
+    <img alt="Qwen-Image" src="https://raw.githubusercontent.com/vllm-project/vllm-omni/refs/heads/main/docs/source/architecture/ar-main-architecture.png" width=30%>
   </picture>
 </p>
 
@@ -38,8 +38,8 @@ According to analysis for current popular open-source models, most of them have
 
 <p align="center">
   <picture>
-    <source media="(prefers-color-scheme: dark)" src="https://raw.githubusercontent.com/vllm-project/vllm-omni/refs/heads/main/docs/source/architecture/ar-main-architecture.png">
-    <img alt="Bagel" src="https://raw.githubusercontent.com/vllm-project/vllm-omni/refs/heads/main/docs/source/architecture/ar-main-architecture.png" width=30%>
+    <source media="(prefers-color-scheme: dark)" src="https://raw.githubusercontent.com/vllm-project/vllm-omni/refs/heads/main/docs/source/architecture/dit-main-architecture.png">
+    <img alt="Bagel" src="https://raw.githubusercontent.com/vllm-project/vllm-omni/refs/heads/main/docs/source/architecture/dit-main-architecture.png" width=30%>
   </picture>
 </p>
 
@@ -64,13 +64,13 @@ According to analysis for current popular open-source models, most of them have
 
 ## Key Components
 
-| Component         | Description                                                                                                                              |
-| ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
-| **OmniRouter**    | provide an intelligent router for Omni-modality requests dispatch                                                                        |
-| **EntryPoints**   | define the APIs for offline/online serving (APIServer, Omni/AsyncOmni) and provide the OmniStage abstraction for different AR/DiT stages |
-| **AR**            | adapted for omni-modality models while inheriting efficient features from vLLM, such as cache management                                 |
-| **Diffusion**     | natively implemented and optimized using acceleration components                                                                         |
-| **OmniConnector** | supports fully disaggregation based on E/P/D/G (Encoding/Processing/Decoding/Generation) disaggregation across stages                    |
+| Component | Description |
+|-----------|-------------|
+| **OmniRouter** | provide an intelligent router for Omni-modality requests dispatch |
+| **EntryPoints** | define the APIs for offline/online serving (APIServer, Omni/AsyncOmni) and provide the OmniStage abstraction for different AR/DiT stages |
+| **AR** | adapted for omni-modality models while inheriting efficient features from vLLM, such as cache management |
+| **Diffusion** | natively implemented and optimized using acceleration components |
+| **OmniConnector** | supports fully disaggregation based on E/P/D/G (Encoding/Processing/Decoding/Generation) disaggregation across stages |
 
 Disaggregated stages are managed through configuration, such as in the Qwen3-Omni example, where stages like Thinker, Talker, and Code2wav are defined as separate OmniStage instances with specific resources and input/output type.
 
@@ -192,4 +192,4 @@ curl -sS -X POST http://localhost:8091/v1/chat/completions \
 }
 ```
 
-For more usages, please refer to [examples](../examples/README.md).
+For more usages, please refer to [examples](../user_guide/examples/).

docs/design/feature/multi_request_streaming_design.md

@@ -0,0 +1,188 @@
+## Multi-Request Streaming (MRS) on a Single Machine
+
+### 1. Background & Scope
+- All processing runs on a single physical machine with multi-process, per-stage workers. No proxy or network transport involved.
+- Current alignment with vllm-omni: `OmniLLM` supports multiple stages (`OmniStage`). GPU runners already expose streamable steps (prefill/decoding/diffusion), but the entry layer still collects lists and lacks intra-stage streaming and window scheduling.
+- Goal: implement multi-stage, multi-request streaming (MRS) locally. Each stage outputs segments; downstream stages stitch and trigger compute based on configured windows. Shared memory and zero-copy strategies reduce data movement overhead.
+
+### 2. Key Constraints
+- Multi-process per stage: each stage is an independent process with a while loop; device visibility can be configured (`CUDA_VISIBLE_DEVICES`/`torch.cuda.set_device`).
+- Simple IPC (copy-based): use `multiprocessing.Queue`/Pipe for inter-process communication with CPU copies/serialization; do not rely on CUDA IPC/SHM zero-copy in this version.
+- Cross-stage pipeline: different stages can process different requests concurrently (e.g., stage A handles request 1 while stage B handles request 0).
+
+### 3. Architecture Overview
+- Processes & IPC queues
+  - Each "sub-stage" is an OS process (worker). The loop: take from input_queue → compute → put to output_queue.
+  - Inter-stage connection via IPC: copy-based `multiprocessing.Queue` passing dict payloads; use shared memory for large objects.
+  - Each link is SPSC (single-producer/single-consumer): the upstream is the orchestrator and the downstream is a single stage process; queues are unbounded (maxsize=0) on the orchestrator side.
+- Device visibility
+  - Each stage sets `CUDA_VISIBLE_DEVICES` or calls `torch.cuda.set_device` to bind to GPU sets.
+  - A stage may use multiple GPUs internally (TP/PP/DP) but presents as a single stage unit.
+- Simplified IPC: copy-based queues/pipes for data transfer; zero-copy is future work.
+- Pipeline progression: when a stage finishes a request, it enqueues outputs to the downstream stage; if downstream is idle, it starts immediately.
+- Scheduling
+  - A downstream stage triggers only after the upstream completes the request.
+  - Windowed segmentation/stitched triggering is not implemented; intra-stage streaming is not provided.
+
+### 7. IPC Implementation (simplified: copy-based)
+- Use `multiprocessing.Queue`/Pipe for inter-process communication (control + data).
+- Data is serialized/copied via CPU; no CUDA IPC/SHM zero-copy in this version.
+- Backpressure: queues are unbounded; pressure manifests as compute-rate differences. Optional SHM reduces large-object transfer cost; RX/decoding overhead is recorded for observability.
+
+### 8. Scheduling & Cancellation (simplified)
+- Pipeline: when a stage finishes a request, it enqueues to the next stage; that stage immediately pulls the next request from its input queue, enabling cross-stage concurrency.
+- Cancellation/timeout: explicit cancellation/timeouts are not provided; graceful shutdown uses a `None` sentinel sent to each stage input queue.
+
+#### Short sequence example (req0/req1, stage A→B)
+1) t0: stage A handles req0
+2) t1: req0 completes on A → enters B; A immediately starts req1
+3) t2: B handles req0 while A handles req1 (parallel across stages)
+
+### 9. Integration Points (by file)
+- `vllm_omni/entrypoints/omni_llm.py` (Orchestrator)
+  - Class `OmniLLM` orchestrates multi-process stages; constructs `OmniStage` instances in parallel and spawns per-stage workers.
+  - Spawns stage processes per config (set `CUDA_VISIBLE_DEVICES`/`torch.cuda.set_device`), creates control/data channels, builds simple full-trigger flow.
+  - Stats/logging are disabled by default; per-stage and orchestrator stats are only written when explicitly enabled.
+  - Manages process lifecycle: start/wait for readiness, graceful shutdown; forwards results between stages using copy-based IPC and optional SHM.
+  - Stage readiness: each stage emits `{"type": "stage_ready"}` after initialization; the orchestrator waits for all stages or times out and logs diagnostic suggestions.
+
+### 9.1 Process Device Visibility
+- Device binding: set `CUDA_VISIBLE_DEVICES` before process start, or call `torch.cuda.set_device` early in init; configs can be single/multi-GPU.
+- Cross-device transfer (simplified): via CPU copies; zero-copy paths are out of scope for now.
+
+### 10. Worker Template (pseudo-code)
+```python
+def stage_worker(input_q, output_q, runtime, shm_threshold):
+    # Device binding
+    set_stage_gpu_devices(runtime.devices)
+    engine = OmniStageLLM(model, **engine_args)
+    batch_seq = 0
+    while True:
+        first = input_q.get()
+        if first is None:
+            break
+        # Batch intake (up to runtime.max_batch_size)
+        batch = [first]
+        while len(batch) < int(runtime.max_batch_size or 1) and not input_q.empty():
+            nxt = input_q.get()
+            if nxt is None:
+                input_q.put(None)
+                break
+            batch.append(nxt)
+        # Decode IPC payload and sampling params
+        request_ids = []
+        engine_inputs = []
+        rx_bytes = {}
+        rx_decode_ms = {}
+        for t in batch:
+            ein, rx = maybe_load_from_ipc_with_metrics(t, "engine_inputs", "engine_inputs_shm")
+            request_ids.append(t["request_id"])
+            engine_inputs.extend(ein if isinstance(ein, list) else [ein])
+            rx_bytes[t["request_id"]] = rx["rx_transfer_bytes"]
+            rx_decode_ms[t["request_id"]] = rx["rx_decode_time_ms"]
+        # Generate and dispatch (grouped by request_id)
+        batch_seq += 1
+        outputs = list(engine.generate(engine_inputs, batch[0]["sampling_params"], use_tqdm=False))
+        grouped = group_by_request_id(outputs, request_ids)
+        for rid in request_ids:
+            r_out = grouped.get(rid, [])
+            use_shm, payload = maybe_dump_to_shm(r_out, shm_threshold)
+            msg = {
+                "request_id": rid,
+                "metrics": {
+                    "batch_id": batch_seq,
+                    "rx_transfer_bytes": int(rx_bytes.get(rid, 0)),
+                    "rx_decode_time_ms": float(rx_decode_ms.get(rid, 0.0)),
+                    # omitted: generation latency and token stats
+                },
+            }
+            if use_shm:
+                msg["engine_outputs_shm"] = payload
+            else:
+                msg["engine_outputs"] = payload
+            output_q.put(msg)
+```
+
+### 12. Observability
+- Metrics (as implemented):
+  - per-request (emitted by stages): `num_tokens_out`, `stage_gen_time_ms`, `rx_transfer_bytes`, `rx_decode_time_ms`, `rx_in_flight_time_ms`, `batch_id`
+  - orchestrator aggregates: E2E latency, tokens/s (written only when stats are enabled)
+  - optional per-stage JSONL: `{log_file}.stage{stage_id}.stats.jsonl`
+- Logs/tracing:
+  - optional per-stage log files: `{log_file}.stage{stage_id}.log`
+  - the orchestrator can log readiness, forward size/time, and summary information
+
+### 15. Risks & Mitigations
+— End-to-end latency: full-trigger sacrifices interactivity; start simple/correct, add windowed streaming later.
+— CPU copy overhead: copy-based IPC for maintainability; add SHM/zero-copy later as an optimization path.
+
+### 16. Refactor: Sink LLM init and process into Stage (diagram)
+
+Objective: without changing external call patterns, encapsulate per-stage LLM init, process creation, and worker logic inside `Stage`, so `PipelinedOmniLLM` focuses on orchestration (seeding, polling, forwarding, collecting) while keeping multi-process, shared memory, and device mapping capabilities.
+
+Key changes (vs. current):
+- Before: Orchestrator created processes directly, passing `_stage_worker`; device setup, LLM init, batching, and SHM were implemented there.
+- After: enhanced `OmniStage` owns its subprocess (`init_stage_worker`), with `_stage_worker` as the entry; device setup, LLM init, batching, and SHM live in `OmniStage`.
+
+Classes & responsibilities
+- OmniLLM (orchestrator)
+  - Build `OmniStage` list in parallel (preserve `process_engine_inputs` wiring)
+  - Connect adjacent `Stage` input/output queues; seed requests to stage 0
+  - Poll stage outputs, decode results, call `process_engine_inputs`, then encode and forward to next stage
+  - Termination & cleanup: distribute shutdown signals; join/terminate subprocesses
+- Stage (stage unit)
+  - Members: `stage_config` (with `engine_args` and `runtime`), `in_q/out_q`, subprocess handle, stats
+  - API:
+    - `init_stage_worker(...)`: spawn subprocess
+    - `stop_stage_worker()`: graceful exit
+    - `submit(ipc_payload)`: submit to input queue (may use shared memory)
+    - `try_collect() -> Optional[payload]`: non-blocking get from output queue
+    - `process_engine_inputs(stages, prompts)`: reuse/delegate existing logic
+  - Subprocess entry `worker_main()`:
+    - `set_stage_gpu_devices` (`CUDA_VISIBLE_DEVICES` & logical index mapping)
+    - build `OmniStageLLM(model, **engine_args)`
+    - while-loop:
+      - take first task + up to `runtime.max_batch_size-1` non-blocking; support `max_batch_size>=1`
+      - `maybe_load_from_ipc_with_metrics` per `engine_inputs` in batch
+      - `stage_engine.generate(batched_inputs, sampling_params)` (window `-1`)
+      - write per-request aggregated outputs to output queue after `maybe_dump_to_shm`
+      - log start/finish; report `error` per request on exceptions
+
+Data flow (sketch)
+```
+OmniLLM
+  ├─ Stage[0].start_process(in0, out0)
+  ├─ Stage[1].start_process(in1, out1)
+  ├─ ...
+  └─ Orchestrator loop:
+       - stage0.submit(encode(engine_inputs))
+       - for each stage:
+           res = stage.try_collect()
+           outputs = decode(res)
+           stage.set_engine_outputs(outputs)
+           if !final: next_inputs = next_stage.process_engine_inputs(stages, original_prompt)
+                    next_stage.submit(encode(next_inputs))
+```
+
+Config (preserve & extend)
+- `runtime.devices`:
+  - Comma-separated visibility list (e.g., "2,5,7"): set visible set; default logical index 0 (first GPU)
+  - Number/string: treat as logical index (0/1-based per implementation) mapping to physical GPUs
+- `runtime.max_batch_size`: max requests taken per intake (default 1)
+- `shm_threshold_bytes`: objects larger than this go via shared memory (default 64KB; injected into stages)
+- Stage link and inputs:
+  - `engine_input_source`: list of upstream stage_id(s) from which the downstream stage takes inputs (typically a single source)
+  - `custom_process_input_func`: function to construct downstream engine_inputs from upstream outputs
+- Output flags:
+  - `final_output`, `final_output_type`: marks that a stage produces the final external output and its type
+
+Kept & strengthened
+- Multi-process: each stage in its own process; parallel across stages; serial/batching inside a stage controlled by `max_batch_size`
+- Shared memory: large objects via SHM with strict `memoryview -> close -> unlink`
+- Device mapping: unified `set_stage_gpu_devices`, support comma lists and logical indices
+
+Migration (execution order)
+1) Enhanced `OmniStage` with `init_stage_worker/stop_stage_worker/submit/try_collect/_stage_worker`.
+2) `OmniLLM` holds `OmniStage` instances, replacing the older pipelined class; uses Stage APIs.
+3) Reuse `entrypoints/stage_utils`: device/SHM/encode-decode utilities live here.
+4) Regression: single/multi-request, various `max_batch_size`, SHM threshold, device mapping, multi-stage parallelism, error paths, and shutdown flows.

docs/design/feature/omni_connector_design.md

@@ -1,4 +1,4 @@
-# Disaggregated Inference for Omni-Modality Models
+# OmniConnector: a unified connector interface of disaggregated inference for omni-modality models
 
 This guide explains how to configure and use distributed connectors (vllm_omni/distributed/connectors) in vllm-omni for multi-stage pipelines.
 

docs/design/feature/ray_based_execution.md

@@ -1,17 +1,14 @@
-# Distributed utils
+# VLLM-Omni Distributed Utilities
 
 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
+
+## 1. 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
+### 1.1 Basic Usage
 
 To use the Ray backend, specify `worker_backend="ray"` when initializing the engine.
 
@@ -24,7 +21,7 @@ vllm serve Qwen/Qwen2.5-Omni-7B \
   --ray-address auto
 ```
 
-### 2.2 Cluster Setup
+### 1.2 Cluster Setup
 
 **Step 1: Start Head Node**
 Run this on your primary machine:
@@ -41,7 +38,7 @@ 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
+### 1.3 Distributed Connector Support
 
 When running on Ray, the system automatically adapts its communication strategy:
 
@@ -49,11 +46,16 @@ When running on Ray, the system automatically adapts its communication strategy:
 *   **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
+### 1.4 Internal Helpers
 
 *   **`initialize_ray_cluster`**: Connects to an existing Ray cluster or starts a local one.
 
-## 3. Troubleshooting
+## 2. 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.
+
+### Installation
+```bash
+pip install "ray[default]"
+```

docs/design/index.md

@@ -8,11 +8,12 @@ This section contains design documents and architecture specifications for vLLM-
 
 ## Feature Design Documents
 
-- [Disaggregated Inference](feature/disaggregated_inference.md)
+- [Multi-Request Streaming](feature/multi_request_streaming_design.md)
+- [Omni Connector Design](feature/omni_connector_design.md)
 - [Ray-based Execution](feature/ray_based_execution.md)
 
 ## Module Design Documents
 
-- [AR Module](module/ar_module.md)
-- [DIT Module](module/dit_module.md)
-- [Entrypoint Module](module/entrypoint_module.md)
+- [AR Module Design](module/ar_module_design.md)
+- [DIT Module Design](module/dit_module_design.md)
+- [Entrypoint Module Design](module/entrypoint_module_design.md)

docs/design/module/ar_module.md

@@ -1,414 +0,0 @@
-# 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 OmniInputProcessor {
-        +process_inputs() OmniEngineCoreRequest
-    }
-
-    class VLLMOutputProcessor {
-        +process_outputs() OutputProcessorOutput
-    }
-    class MultimodalOutputProcessor {
-        +process_outputs() OutputProcessorOutput
-        +_route_and_normalize()
-    }
-    InputProcessor <|-- OmniInputProcessor
-    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**: `OmniInputProcessor` extends `vllm.v1.engine.input_processor.InputProcessor` to serialize prompt embeddings and additional information
-- **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[OmniInputProcessor] -->|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 OmniInputProcessor
-    participant Scheduler
-    participant ModelRunner
-    participant MultimodalOutputProcessor
-    participant Client
-
-    Client->>OmniInputProcessor: prompt + prompt_embeds + additional_info
-    OmniInputProcessor->>OmniInputProcessor: Serialize tensors to payloads
-    OmniInputProcessor->>Scheduler: OmniEngineCoreRequest (with payloads)
-    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)
-```
-
-### OmniInputProcessor
-
-`OmniInputProcessor` extends the base input processor to serialize prompt embeddings and additional information for inter-stage transfer.
-
-#### Payload Serialization
-
-Converts PyTorch tensors to serialized payloads:
-
-```python
-def process_inputs(self, ...) -> OmniEngineCoreRequest:
-    # Serialize prompt_embeds
-    if "prompt_embeds" in decoder_inputs:
-        pe_cpu = decoder_inputs["prompt_embeds"].detach().to("cpu").contiguous()
-        prompt_embeds_payload = PromptEmbedsPayload(
-            data=pe_cpu.numpy().tobytes(),
-            shape=[seq_len, hidden_size],
-            dtype=dtype_str,
-        )
-
-    # Serialize additional_information
-    if "additional_information" in decoder_inputs:
-        entries = {}
-        for key, value in raw_info.items():
-            if isinstance(value, torch.Tensor):
-                entry = AdditionalInformationEntry(
-                    tensor_data=value.numpy().tobytes(),
-                    tensor_shape=list(value.shape),
-                    tensor_dtype=dtype_str,
-                )
-            entries[key] = entry
-        additional_information_payload = AdditionalInformationPayload(entries=entries)
-
-    return OmniEngineCoreRequest(
-        # ... standard fields ...
-        prompt_embeds=prompt_embeds_payload,
-        additional_information=additional_information_payload,
-    )
-```
-
-### 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 `PromptEmbedsPayload` and `AdditionalInformationPayload` for efficient inter-stage data 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 prompt embeddings and additional information 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.

docs/design/module/ar_module_design.md

@@ -0,0 +1 @@
+Architecture design of the AR module (update soon)

docs/design/module/dit_module.md

@@ -1,906 +0,0 @@
----
-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 manages the lifecycle of worker processes and coordinates the execution flow.
-
-### Key Components
-
-#### 1.1 Initialization
-
-```python
-class DiffusionEngine:
-    def __init__(self, od_config: OmniDiffusionConfig):
-        self.od_config = od_config
-        self.post_process_func = get_diffusion_post_process_func(od_config)
-        self.pre_process_func = get_diffusion_pre_process_func(od_config)
-        self._processes: list[mp.Process] = []
-        self._make_client()
-```
-
-**Key Features**:
-
-- **Pre/Post Processing**: Registers model-specific pre-processing and post-processing functions via registry pattern
-
-- **Worker Management**: Launches and manages multiple worker processes (one per GPU)
-
-- **Process Isolation**: Uses multiprocessing for true parallelism
-
-#### 1.2 Worker Launch Process
-
-The engine launches workers using a **spawn** method:
-
-```python
-def _launch_workers(self, broadcast_handle):
-    # Creates one process per GPU
-    for i in range(num_gpus):
-        process = mp.Process(
-            target=worker_proc.worker_main,
-            args=(i, od_config, writer, broadcast_handle),
-            name=f"DiffusionWorker-{i}",
-        )
-        process.start()
-```
-
-**Design Decisions**:
-
-- **Spawn Method**: Ensures clean state for each worker (no shared memory issues)
-
-- **Pipe Communication**: Uses `mp.Pipe` for initialization handshake
-
-- **Device Selection**: Each worker is assigned a specific GPU (`cuda:{rank}`)
-
-#### 1.3 Request Processing Flow
-
-```python
-def step(self, requests: list[OmniDiffusionRequest]):
-    # 1. Pre-process requests
-    requests = self.pre_process_func(requests)
-
-    # 2. Send to scheduler and wait for response
-    output = self.add_req_and_wait_for_response(requests)
-
-    # 3. Post-process results
-    result = self.post_process_func(output.output)
-    return result
-```
-
-**Flow**:
-
-1. **Pre-processing**: Applies model-specific transformations
-
-2. **Scheduling**: Delegates to scheduler for distribution
-
-3. **Post-processing**: Converts raw outputs to final format (e.g., PIL images)
-
----
-
-## 2. Scheduler
-
-**Location**: `vllm_omni/diffusion/scheduler.py`
-
-### Architecture
-
-The `Scheduler` is implemented as a **Singleton** pattern to ensure a single coordination point across the system, i.e., only one scheduler instance exists for coordination.
-
-### Key Components
-
-#### 2.1 Message Queue System
-
-```python
-class Scheduler:
-    def initialize(self, od_config: OmniDiffusionConfig):
-        # Broadcast queue: scheduler -> all workers
-        self.mq = MessageQueue(
-            n_reader=od_config.num_gpus,
-            n_local_reader=od_config.num_gpus,
-            local_reader_ranks=list(range(od_config.num_gpus)),
-        )
-
-        # Result queue: rank 0 worker -> scheduler
-        self.result_mq = None  # Initialized later
-```
-
-**Communication Pattern**:
-
-- **Broadcast Queue**: One-to-many communication (scheduler → all workers)
-
-- **Result Queue**: One-to-one communication (rank 0 → scheduler)
-
-- **Shared Memory**: Uses `MessageQueue` (ZMQ-based) for efficient IPC
-
-#### 2.2 Request Distribution
-
-```python
-def add_req(self, requests: list[OmniDiffusionRequest]) -> DiffusionOutput:
-    # Broadcast request to all workers
-    self.mq.enqueue(requests)
-
-    # Wait for result from Rank 0
-    output = self.result_mq.dequeue()
-    return output
-```
-
-**Design Features**:
-
-- **Broadcast Model**: All workers receive the same request (for tensor parallelism)
-
-- **Single Response**: Only rank 0 sends results back (avoids duplicate outputs)
-
-- **Synchronous**: Blocks until result is received (can be made async)
-
-#### 2.3 Singleton Pattern
-
-```python
-class Scheduler:
-    _instance = None
-
-    def __new__(cls, *args, **kwargs):
-        if not cls._instance:
-            cls._instance = super().__new__(cls)
-        return cls._instance
-
-# Global singleton instance
-scheduler = Scheduler()
-```
-
-**Benefits**:
-
-- **Single Point of Control**: Ensures consistent state
-
-- **Easy Access**: Global `scheduler` instance accessible everywhere
-
-- **Resource Management**: Centralized queue management
-
----
-
-## 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 = GPUWorker(local_rank=gpu_id, rank=gpu_id, od_config=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 GPUWorker:
-    def init_device_and_model(self):
-        # Set distributed environment variables
-        os.environ["RANK"] = str(rank)
-        os.environ["WORLD_SIZE"] = str(world_size)
-
-        # Initialize PyTorch distributed
-        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,
-        )
-
-        # Load model
-        model_loader = DiffusersPipelineLoader(load_config)
-        self.pipeline = model_loader.load_model(od_config, load_device=f"cuda:{rank}")
-
-        # Setup cache backend
-        from vllm_omni.diffusion.cache.selector import get_cache_backend
-        self.cache_backend = get_cache_backend(od_config.cache_backend, od_config.cache_config)
-
-        if self.cache_backend is not None:
-            self.cache_backend.enable(self.pipeline)
-```
-
-**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.recv_message()
-
-        # 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 **backend selector pattern** that automatically chooses the optimal attention implementation based on hardware and model configuration.
-
-#### Backend Selection
-
-**Location**: `vllm_omni/diffusion/attention/selector.py`
-
-```python
-class Attention(nn.Module):
-    def __init__(self, num_heads, head_size, causal, softmax_scale, ...):
-        # Auto-select backend
-        self.attn_backend = get_attn_backend(-1)
-        self.attn_impl_cls = self.attn_backend.get_impl_cls()
-        self.attention = self.attn_impl_cls(...)
-```
-
-**Available Backends**:
-
-- **FlashAttention**: Optimized CUDA kernel (FA2/FA3) - memory efficient via tiling
-
-- **SDPA**: PyTorch's scaled dot-product attention - default, cross-platform
-
-- **SageAttention**: Sparse attention implementation from SageAttention library
-
-- **AscendAttention**: NPU-optimized attention for Ascend hardware
-
-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
-
-```python
-def get_attn_backend(head_size: int) -> type[AttentionBackend]:
-    # Check environment variable
-    backend_name = os.environ.get("DIFFUSION_ATTENTION_BACKEND")
-
-    if backend_name:
-        return load_backend(backend_name.upper())
-
-    # Default to SDPA
-    return SDPABackend
-```
-
-**Selection Priority**:
-
-1. **Environment Variable**: `DIFFUSION_ATTENTION_BACKEND` for manual override
-
-    - Valid values: `FLASH_ATTN`, `TORCH_SDPA`, `SAGE_ATTN`, `ASCEND`
-
-    - Example: `export DIFFUSION_ATTENTION_BACKEND=SAGE_ATTN`
-
-2. **Automatic Fallback**: Falls back to SDPA if selected backend unavailable
-
-3. **Hardware Detection**: Can select based on device type (NPU, CUDA, etc.)
-
-**Backend Availability**:
-
-- **SDPA**: Always available (PyTorch built-in)
-
-- **FlashAttention**: Requires `flash-attn` package installed
-
-- **SageAttention**: Requires `sage-attention` package (from THU-ML GitHub)
-
-- **AscendAttention**: Only available on Ascend NPU hardware
-
-#### Attention Backend Registry
-
-**Location**: `vllm_omni/diffusion/attention/selector.py`
-
-The attention system uses a **registry pattern** to manage and dynamically load attention backends. This allows for easy extension and runtime selection of backends.
-
-
-**Registry Structure**:
-
-```python
-# Registry mapping backend names to their module paths and class names
-_BACKEND_CONFIG = {
-    "FLASH_ATTN": {
-        "module": "vllm_omni.diffusion.attention.backends.flash_attn",
-        "class": "FlashAttentionBackend",
-    },
-    "TORCH_SDPA": {
-        "module": "vllm_omni.diffusion.attention.backends.sdpa",
-        "class": "SDPABackend",
-    },
-    "SAGE_ATTN": {
-        "module": "vllm_omni.diffusion.attention.backends.sage_attn",
-        "class": "SageAttentionBackend",
-    },
-    "ASCEND": {
-        "module": "vllm_omni.diffusion.attention.backends.ascend_attn",
-        "class": "AscendAttentionBackend",
-    },
-}
-```
-
-#### 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/cache_dit_backend.py`
-
-```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
-   └─> OmniDiffusion.generate(prompt)
-       └─> Prepare OmniDiffusionRequest
-           └─> DiffusionEngine.step(requests)
-
-2. Pre-processing
-   └─> pre_process_func(requests)
-       └─> Model-specific transformations
-
-3. Scheduling
-   └─> scheduler.add_req(requests)
-       └─> Broadcast via MessageQueue to all workers
-
-4. Worker Execution
-   └─> WorkerProc.worker_busy_loop()
-       └─> GPUWorker.execute_model(reqs)
-           └─> Pipeline.forward(req)
-               ├─> encode_prompt()
-               ├─> prepare_latents()
-               ├─> diffuse() [loop]
-               │   ├─> transformer.forward() [with cache backend hooks]
-               │   └─> scheduler.step()
-               └─> vae.decode()
-
-5. Result Collection
-   └─> Rank 0 sends DiffusionOutput via result queue
-       └─> Scheduler receives and returns
-
-6. Post-processing
-   └─> post_process_func(output)
-       └─> Convert to PIL images / final format
-```
-
----

docs/design/module/dit_module_design.md

@@ -0,0 +1 @@
+Architecture design of the DiT module (update soon)

docs/features/sleep_mode.md

@@ -1,39 +0,0 @@
-# Sleep Mode
-
-vLLM-Omni’s **Sleep Mode** allows you to temporarily release most GPU memory used by a model—such as model weights and key-value (KV) caches (for autoregressive models)—**without stopping the server or unloading the Docker container**.
-
-This feature is inherited from [vLLM’s Sleep Mode](https://blog.vllm.ai/2025/10/26/sleep-mode.html), which provides zero-reload model switching for multi-model serving.  
-
-It is especially useful in **RLHF**, **training**, or **cost-saving scenarios**, where GPU resources must be freed between inference workloads.
-
----
-
-## Omni Model
-
-Omni model inherit the feature from vLLM' Sleep Mode
-
-This means:
-
-- Support both Level 1 and Level 2 sleep, allow to release and reset both model weights and KV Cache
-
-## Diffusion Model Extension
-
-We added Sleep Mode support for **diffusion models**, which previously lacked this functionality.  
-In diffusion pipelines, this currently only offloads **model weight memory**, as these models typically do not use KV caches.
-
-This means:
-
-- Diffusion models can now enter Level 1 sleep.
-- Pipeline states (e.g., noise schedulers, buffers) remain intact after waking.
-- Useful for releasing VRAM between image generation or training cycles.
-
----
-
-## Enable sleep mode
-To enable sleep mode, set the `enable_sleep_mode` in `engine_args` to `True`
-
-
-Example:
-```python
-omni = Omni(model=...,enable_sleep_mode=True)
-```

docs/getting_started/installation/gpu.md

@@ -49,18 +49,18 @@ vLLM-Omni is a Python library that supports the following GPU variants. The libr
 
 ## Set up using Docker
 
+### Build wheel from source
+
+=== "NVIDIA CUDA"
+
+    --8<-- "docs/getting_started/installation/gpu/cuda.inc.md:build-wheel-from-source-in-docker"
+
+=== "AMD ROCm"
+
+    --8<-- "docs/getting_started/installation/gpu/rocm.inc.md:build-wheel-from-source-in-docker"
+
 ### Pre-built images
 
 === "NVIDIA CUDA"
 
     --8<-- "docs/getting_started/installation/gpu/cuda.inc.md:pre-built-images"
-
-=== "AMD ROCm"
-
-    --8<-- "docs/getting_started/installation/gpu/rocm.inc.md:pre-built-images"
-
-### Build your own docker image
-
-=== "AMD ROCm"
-
-    --8<-- "docs/getting_started/installation/gpu/rocm.inc.md:build-docker"

docs/getting_started/installation/gpu/cuda.inc.md

@@ -17,12 +17,10 @@ Therefore, it is recommended to install vLLM and vLLM-Omni with a **fresh new**
 # --8<-- [start:pre-built-wheels]
 
 #### Installation of vLLM
-Note: Pre-built wheels are currently only available for vLLM-Omni 0.11.0rc1 and 0.12.0rc1. For the latest version, please [build from source](https://docs.vllm.ai/projects/vllm-omni/en/latest/getting_started/installation/gpu/#build-wheel-from-source).
 
-
-vLLM-Omni is built based on vLLM. Please install it with command below.
+vLLM-Omni is built based on vLLM v0.11.0. Please install it with command below.
 ```bash
-uv pip install vllm==0.12.0 --torch-backend=auto
+uv pip install vllm==0.11.0 --torch-backend=auto
 ```
 
 #### Installation of vLLM-Omni
@@ -36,16 +34,14 @@ uv pip install vllm-omni
 # --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.12.0 release version of the library
+If you do not need to modify source code of vLLM, you can directly install the stable 0.11.0 release version of the library
 
 ```bash
-uv pip install vllm==0.12.0 --torch-backend=auto
+uv pip install vllm==0.11.0 --torch-backend=auto
 ```
 
-The release 0.12.0 of vLLM is based on PyTorch 2.9.0 which requires CUDA 12.9 environment.
-
 #### Installation of vLLM-Omni
-Since vllm-omni is rapidly evolving, it's recommended to install it from source
+Install additional requirements for vLLM-Omni
 ```bash
 git clone https://github.com/vllm-project/vllm-omni.git
 cd vllm-omni
@@ -58,11 +54,11 @@ 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.12.0
+git checkout v0.11.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
-export VLLM_PRECOMPILED_WHEEL_LOCATION=https://github.com/vllm-project/vllm/releases/download/v0.12.0/vllm-0.12.0-cp38-abi3-manylinux_2_31_x86_64.whl
+export VLLM_PRECOMPILED_WHEEL_LOCATION=https://github.com/vllm-project/vllm/releases/download/v0.11.0/vllm-0.11.0-cp38-abi3-manylinux1_x86_64.whl
 ```
 Install vllm with command below (If you have no existing PyTorch).
 ```bash
@@ -93,7 +89,7 @@ docker run --runtime nvidia --gpus 2 \
     --env "HF_TOKEN=$HF_TOKEN" \
     -p 8091:8091 \
     --ipc=host \
-    vllm/vllm-omni:v0.12.0rc1 \
+    vllm/vllm-omni:v0.11.0rc1 \
     --model Qwen/Qwen3-Omni-30B-A3B-Instruct --port 8091
 ```
 

docs/getting_started/installation/gpu/rocm.inc.md

@@ -15,79 +15,101 @@ vLLM-Omni current recommends the steps in under setup through Docker Images.
 
 # --8<-- [end:build-wheel-from-source]
 
-# --8<-- [start:build-docker]
+# --8<-- [start:build-wheel-from-source-in-docker]
 
-#### Build docker image
+#### Get the correct docker environment
+
+The v0.11.0 releases is on Oct 3, 2025, so we will pull a AMD nightly docker image close to the release period. `rocm/vllm-dev:nightly_main_20251005` is picked as it has a correct `transformers` version that supports qwen3_omni.
+
+`docker pull rocm/vllm-dev:nightly_main_20251005`
+
+#### Launch the docker environment
+
+In this docker environment, we have all the dependencies for vLLM installed, like `flash-attn` and `aiter`
 
 ```bash
-DOCKER_BUILDKIT=1 docker build -f docker/Dockerfile.rocm -t vllm-omni-rocm .
-```
-
-If you want to specify which GPU Arch to build for to cutdown build time:
-
-```bash
-DOCKER_BUILDKIT=1 docker build \
-  -f docker/Dockerfile.rocm \
-  --build-arg PYTORCH_ROCM_ARCH="gfx942;gfx950" \
-  -t vllm-omni-rocm .
-```
-
-#### Launch the docker image
-
-```
+#!/bin/bash
 docker run -it \
---network=host \
---group-add=video \
---ipc=host \
---cap-add=SYS_PTRACE \
---security-opt seccomp=unconfined \
---device /dev/kfd \
---device /dev/dri \
--v <path/to/model>:/app/model \
-vllm-omni-rocm \
-bash
+   --privileged \
+   --network=host \
+   --group-add=video \
+   --ipc=host \
+   --cap-add=SYS_PTRACE \
+   --security-opt seccomp=unconfined \
+   --device /dev/kfd \
+   --device /dev/dri \
+   --name vllmomni \
+   rocm/vllm-dev:nightly_main_20251005 \
+   bash
 ```
 
-# --8<-- [end:build-docker]
+#### Update docker dependencies
+
+```bash
+sudo apt update
+sudo apt install ffmpeg -y
+```
+
+#### Installation of vLLM
+Install the v0.11.0 release of vLLM as vLLM-Omni is currently depend on v0.11.0.
+
+```bash
+# uninstall existing vllm which is based on the main branch, not on the releases branch
+python3 -m pip uninstall -y vllm
+git clone https://github.com/vllm-project/vllm.git vllm0110
+cd vllm0110/
+
+# checkout the version tag v0.11.0
+git checkout -b v0.11.0 v0.11.0
+
+# you should see 0.11.0
+python -c "import setuptools_scm; print(setuptools_scm.get_version())"
+
+# PYTORCH_ROCM_ARCH=<your-gpu-arch> python3 setup.py develop
+PYTORCH_ROCM_ARCH=gfx942 python3 setup.py develop
+```
+
+!!! note
+    vLLM release wheels based on the branch with prefix `releases/`, not from the tag as vLLM may cherry pick bugfixes after cutting a branch.
+
+
+#### Installation of vLLM-Omni
+
+There are two approaches to installing `vllm-omni`
+
+
+1. Install from PyPI
+
+```bash
+pip install vllm-omni
+
+# you might want to also download the source code of the same version to run the examples
+```
+
+2. Install from source
+
+```bash
+# clone and checkout to the release version.
+git clone https://github.com/vllm-project/vllm-omni.git
+cd vllm-omni
+git checkout v0.11.0rc1
+pip install -e .
+```
+
+#### Setup Environment Variables
+
+After installing `vllm` and `vllm-omni` please setup the environment variable as well before running any of the examples and command.
+
+```bash
+export MIOPEN_FIND_MODE=FAST
+export VLLM_ROCM_USE_AITER=1
+export VLLM_ROCM_USE_AITER_MHA=1
+export VLLM_ROCM_USE_AITER_LINEAR=0
+export VLLM_ROCM_USE_AITER_RMSNORM=0
+```
+
+# --8<-- [end:build-wheel-from-source-in-docker]
 
 # --8<-- [start:pre-built-images]
 
-vLLM-Omni offers an official docker image for deployment. These images are built on top of vLLM docker images and available on Docker Hub as [vllm/vllm-omni-rocm](https://hub.docker.com/r/vllm/vllm-omni-rocm/tags). The version of vLLM-Omni indicates which release of vLLM it is based on.
-
-#### Launch vLLM-Omni Server
-Here's an example deployment command that has been verified on 2 x MI300's:
-```bash
-docker run -it \
-  --network=host \
-  --group-add=video \
-  --ipc=host \
-  --cap-add=SYS_PTRACE \
-  --security-opt seccomp=unconfined \
-  --device /dev/kfd \
-  --device /dev/dri \
-  -v <path/to/model>:/app/model \
-  -v ~/.cache/huggingface:/root/.cache/huggingface \
-  --env "HF_TOKEN=$HF_TOKEN" \
-  vllm/vllm-omni-rocm:v0.12.0rc1 \
-  vllm serve --model Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --port 8091
-```
-
-#### Launch an interactive terminal with prebuilt docker image.
-If you want to run in dev environment you can launch the docker image as follows:
-```bash
-docker run -it \
-  --network=host \
-  --group-add=video \
-  --ipc=host \
-  --cap-add=SYS_PTRACE \
-  --security-opt seccomp=unconfined \
-  --device /dev/kfd \
-  --device /dev/dri \
-  -v <path/to/model>:/app/model \
-  -v ~/.cache/huggingface:/root/.cache/huggingface \
-  --env "HF_TOKEN=$HF_TOKEN" \
-  vllm/vllm-omni-rocm:v0.12.0rc1 \
-  bash
-```
-
 # --8<-- [end:pre-built-images]

docs/getting_started/installation/npu/npu.inc.md

@@ -13,10 +13,10 @@ export DEVICE0=/dev/davinci0
 export DEVICE1=/dev/davinci1
 # Update the vllm-ascend image
 # Atlas A2:
-# export IMAGE=quay.io/ascend/vllm-ascend:v0.12.0rc1
+# export IMAGE=quay.io/ascend/vllm-ascend:v0.11.0rc2
 # Atlas A3:
-# export IMAGE=quay.io/ascend/vllm-ascend:v0.12.0rc1-a3
-export IMAGE=quay.io/ascend/vllm-ascend:v0.12.0rc1
+# export IMAGE=quay.io/ascend/vllm-ascend:v0.11.0rc2-a3
+export IMAGE=quay.io/ascend/vllm-ascend:v0.11.0rc2
 docker run --rm \
     --name vllm-omni-npu \
     --shm-size=1g \
@@ -34,22 +34,12 @@ docker run --rm \
     -p 8000:8000 \
     -it $IMAGE bash
 
-# Install the missing dependency of mooncake in the origin image.
-apt update
-apt install libjemalloc2
-echo "export LD_PRELOAD=/usr/lib/$(uname -m)-linux-gnu/libjemalloc.so.2:$LD_PRELOAD" >> ~/.bashrc
-source ~/.bashrc
-
 # Inside the container, install vLLM-Omni from source
 cd /vllm-workspace
-git clone -b v0.12.0rc1 https://github.com/vllm-project/vllm-omni.git
+git clone https://github.com/vllm-project/vllm-omni.git
 cd vllm-omni
 pip install -v -e .
 export VLLM_WORKER_MULTIPROC_METHOD=spawn
-
-# (Optional) Disable mooncake for stable capability
-mv /usr/local/Ascend/ascend-toolkit/latest/python/site-packages/mooncake \
-   /usr/local/Ascend/ascend-toolkit/latest/python/site-packages/mooncake.disabled
 ```
 
 The default workdir is `/workspace`, with vLLM, vLLM-Ascend and vLLM-Omni code placed in `/vllm-workspace` installed in development mode.

docs/getting_started/quickstart.md

@@ -12,18 +12,7 @@ This guide will help you quickly get started with vLLM-Omni to perform:
 
 ## Installation
 
-For installation on GPU from source:
-
-```bash
-uv venv --python 3.12 --seed
-source .venv/bin/activate
-uv pip install vllm==0.12.0 --torch-backend=auto
-git clone https://github.com/vllm-project/vllm-omni.git
-cd vllm-omni
-uv pip install -e .
-```
-
-For additional installation methods — please see the [installation guide](installation/README.md).
+Please refer to [installation](installation/README.md)
 
 ## Offline Inference
 
@@ -35,8 +24,7 @@ from vllm_omni.entrypoints.omni import Omni
 if __name__ == "__main__":
     omni = Omni(model="Tongyi-MAI/Z-Image-Turbo")
     prompt = "a cup of coffee on the table"
-    outputs = omni.generate(prompt)
-    images = outputs[0].request_output[0].images
+    images = omni.generate(prompt)
     images[0].save("coffee.png")
 ```
 
@@ -44,27 +32,4 @@ For more usages, please refer to [offline inference](../user_guide/examples/offl
 
 ## Online Serving with OpenAI-Completions API
 
-Text-to-image generation quickstart with vLLM-Omni:
-
-```bash
-vllm serve Tongyi-MAI/Z-Image-Turbo --omni --port 8091
-```
-
-```bash
-curl -s http://localhost:8091/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -d '{
-    "messages": [
-      {"role": "user", "content": "a cup of coffee on the table"}
-    ],
-    "extra_body": {
-      "height": 1024,
-      "width": 1024,
-      "num_inference_steps": 50,
-      "guidance_scale": 4.0,
-      "seed": 42
-    }
-  }' | jq -r '.choices[0].message.content[0].image_url.url' | cut -d',' -f2 | base64 -d > coffee.png
-```
-
-For more details, please refer to [online serving](../user_guide/examples/online_serving/text_to_image.md).
+Please refer to [online serving](../user_guide/examples/online_serving/qwen2_5_omni.md)

docs/mkdocs/hooks/generate_api_readme.py

@@ -136,15 +136,6 @@ def scan_package(package_name: str = "vllm_omni") -> dict[str, list[str]]:
             relative_path = py_file.relative_to(ROOT_DIR)
             module_path = str(relative_path.with_suffix("")).replace("/", ".").replace("\\", ".")
 
-            # Skip excluded modules (avoid importing vllm during docs build)
-            excluded_prefixes = [
-                "vllm_omni.diffusion.models.qwen_image",
-                "vllm_omni.entrypoints.async_diffusion",
-                "vllm_omni.entrypoints.openai",
-            ]
-            if any(module_path.startswith(prefix) for prefix in excluded_prefixes):
-                continue
-
             # Handle __init__.py - use parent module path
             if py_file.name == "__init__.py":
                 # Remove .__init__ from module path

docs/mkdocs/hooks/generate_examples.py

@@ -195,7 +195,7 @@ class Example:
             main_file_rel = self.main_file.relative_to(ROOT_DIR)
             content += f'{code_fence}{self.main_file.suffix[1:]}\n--8<-- "{main_file_rel}"\n{code_fence}\n'
         else:
-            with open(self.main_file, encoding="utf-8") as f:
+            with open(self.main_file) as f:
                 # Skip the title from md snippets as it's been included above
                 main_content = f.readlines()[1:]
             content += self.fix_relative_links("".join(main_content))

docs/mkdocs/javascript/mermaid.js

@@ -1,21 +0,0 @@
-// Initialize Mermaid for diagram rendering
-mermaid.initialize({
-  startOnLoad: false,
-  theme: 'default',
-  securityLevel: 'loose',
-  flowchart: {
-    useMaxWidth: true,
-    htmlLabels: true
-  }
-});
-
-// Render Mermaid diagrams when page content is ready
-document$.subscribe(() => {
-  const mermaidElements = document.querySelectorAll('.mermaid');
-  if (mermaidElements.length > 0) {
-    mermaid.run({
-      querySelector: '.mermaid',
-      nodes: mermaidElements
-    });
-  }
-});

docs/models/supported_models.md

@@ -19,21 +19,10 @@ th {
 |--------------|--------|-------------------|
 | `Qwen3OmniMoeForConditionalGeneration` | Qwen3-Omni | `Qwen/Qwen3-Omni-30B-A3B-Instruct` |
 | `Qwen2_5OmniForConditionalGeneration` | Qwen2.5-Omni | `Qwen/Qwen2.5-Omni-7B`, `Qwen/Qwen2.5-Omni-3B` |
-| `BagelForConditionalGeneration` | BAGEL (DiT-only) | `ByteDance-Seed/BAGEL-7B-MoT` |
 | `QwenImagePipeline` | Qwen-Image | `Qwen/Qwen-Image` |
-| `QwenImagePipeline` | Qwen-Image-2512 | `Qwen/Qwen-Image-2512` |
 | `QwenImageEditPipeline` | Qwen-Image-Edit | `Qwen/Qwen-Image-Edit` |
-| `QwenImageEditPlusPipeline` | Qwen-Image-Edit-2509 | `Qwen/Qwen-Image-Edit-2509` |
-| `QwenImageLayeredPipeline` | Qwen-Image-Layered | `Qwen/Qwen-Image-Layered` |
 |`ZImagePipeline` | Z-Image | `Tongyi-MAI/Z-Image-Turbo` |
-| `WanPipeline` | Wan2.2-T2V, Wan2.2-TI2V | `Wan-AI/Wan2.2-T2V-A14B-Diffusers`, `Wan-AI/Wan2.2-TI2V-5B-Diffusers` |
-| `WanImageToVideoPipeline` | Wan2.2-I2V | `Wan-AI/Wan2.2-I2V-A14B-Diffusers` |
-| `OvisImagePipeline` | Ovis-Image | `OvisAI/Ovis-Image` |
-|`LongcatImagePipeline` | LongCat-Image | `meituan-longcat/LongCat-Image` |
-|`LongCatImageEditPipeline` | LongCat-Image-Edit | `meituan-longcat/LongCat-Image-Edit` |
-|`StableDiffusion3Pipeline` | Stable-Diffusion-3 | `stabilityai/stable-diffusion-3.5-medium` |
-|`Flux2KleinPipeline` | FLUX.2-klein | `black-forest-labs/FLUX.2-klein-4B`, `black-forest-labs/FLUX.2-klein-9B` |
-|`StableAudioPipeline` | Stable-Audio-Open | `stabilityai/stable-audio-open-1.0` |
+| `WanPipeline` | Wan2.2 | `Wan-AI/Wan2.2-T2V-A14B-Diffusers` |
 
 
 ## List of Supported Models for NPU
@@ -49,9 +38,3 @@ th {
 |--------------|--------|-------------------|
 | `Qwen2_5OmniForConditionalGeneration` | Qwen2.5-Omni | `Qwen/Qwen2.5-Omni-7B`, `Qwen/Qwen2.5-Omni-3B`|
 | `QwenImagePipeline` | Qwen-Image | `Qwen/Qwen-Image` |
-| `QwenImagePipeline` | Qwen-Image-2512 | `Qwen/Qwen-Image-2512` |
-| `QwenImageEditPipeline` | Qwen-Image-Edit | `Qwen/Qwen-Image-Edit` |
-| `QwenImageEditPlusPipeline` | Qwen-Image-Edit-2509 | `Qwen/Qwen-Image-Edit-2509` |
-| `QwenImageLayeredPipeline` | Qwen-Image-Layered | `Qwen/Qwen-Image-Layered` |
-| `QwenImageEditPlusPipeline` | Qwen-Image-Edit-2511 | `Qwen/Qwen-Image-Edit-2511` |
-|`ZImagePipeline` | Z-Image | `Tongyi-MAI/Z-Image-Turbo` |

docs/serving/image_generation_api.md

@@ -1,249 +0,0 @@
-# Image Generation API
-
-vLLM-Omni provides an OpenAI DALL-E compatible API for text-to-image generation using diffusion models.
-
-Each server instance runs a single model (specified at startup via `vllm serve <model> --omni`).
-
-## Quick Start
-
-### Start the Server
-
-For example...
-
-```bash
-# Qwen-Image
-vllm serve Qwen/Qwen-Image --omni --port 8000
-
-# Z-Image Turbo
-vllm serve Tongyi-MAI/Z-Image-Turbo --omni --port 8000
-```
-
-### Generate Images
-
-**Using curl:**
-
-```bash
-curl -X POST http://localhost:8000/v1/images/generations \
-  -H "Content-Type: application/json" \
-  -d '{
-    "prompt": "a dragon laying over the spine of the Green Mountains of Vermont",
-    "size": "1024x1024",
-    "seed": 42
-  }' | jq -r '.data[0].b64_json' | base64 -d > dragon.png
-```
-
-**Using Python:**
-
-```python
-import requests
-import base64
-from PIL import Image
-import io
-
-response = requests.post(
-    "http://localhost:8000/v1/images/generations",
-    json={
-        "prompt": "a black and white cat wearing a princess tiara",
-        "size": "1024x1024",
-        "num_inference_steps": 50,
-        "seed": 42,
-    }
-)
-
-# Decode and save
-img_data = response.json()["data"][0]["b64_json"]
-img_bytes = base64.b64decode(img_data)
-img = Image.open(io.BytesIO(img_bytes))
-img.save("cat.png")
-```
-
-**Using OpenAI SDK:**
-
-```python
-from openai import OpenAI
-
-client = OpenAI(base_url="http://localhost:8000/v1", api_key="none")
-
-response = client.images.generate(
-    model="Qwen/Qwen-Image",
-    prompt="a horse jumping over a fence nearby a babbling brook",
-    n=1,
-    size="1024x1024",
-    response_format="b64_json"
-)
-
-# Note: Extension parameters (seed, steps, cfg) require direct HTTP requests
-```
-
-## API Reference
-
-### Endpoint
-
-```
-POST /v1/images/generations
-Content-Type: application/json
-```
-
-### Request Parameters
-
-#### OpenAI Standard Parameters
-
-| Parameter | Type | Default | Description |
-|-----------|------|---------|-------------|
-| `prompt` | string | **required** | Text description of the desired image |
-| `model` | string | server's model | Model to use (optional, should match server if specified) |
-| `n` | integer | 1 | Number of images to generate (1-10) |
-| `size` | string | model defaults | Image dimensions in WxH format (e.g., "1024x1024", "512x512") |
-| `response_format` | string | "b64_json" | Response format (only "b64_json" supported) |
-| `user` | string | null | User identifier for tracking |
-
-#### vllm-omni Extension Parameters
-
-| Parameter | Type | Default | Description |
-|-----------|------|---------|-------------|
-| `negative_prompt` | string | null | Text describing what to avoid in the image |
-| `num_inference_steps` | integer | model defaults | Number of diffusion steps |
-| `guidance_scale` | float | model defaults | Classifier-free guidance scale (typically 0.0-20.0) |
-| `true_cfg_scale` | float | model defaults | True CFG scale (model-specific parameter, may be ignored if not supported) |
-| `seed` | integer | null | Random seed for reproducibility |
-
-### Response Format
-
-```json
-{
-  "created": 1701234567,
-  "data": [
-    {
-      "b64_json": "<base64-encoded PNG>",
-      "url": null,
-      "revised_prompt": null
-    }
-  ]
-}
-```
-
-## Examples
-
-### Multiple Images
-
-```bash
-curl -X POST http://localhost:8000/v1/images/generations \
-  -H "Content-Type: application/json" \
-  -d '{
-    "prompt": "a steampunk city set in a valley of the Adirondack mountains",
-    "n": 4,
-    "size": "1024x1024",
-    "seed": 123
-  }'
-```
-
-This generates 4 images in a single request.
-
-### With Negative Prompt
-
-```python
-response = requests.post(
-    "http://localhost:8000/v1/images/generations",
-    json={
-        "prompt": "a portrait of a skier in deep powder snow",
-        "negative_prompt": "blurry, low quality, distorted, ugly",
-        "num_inference_steps": 100,
-        "size": "1024x1024",
-    }
-)
-```
-
-## Parameter Handling
-
-The API passes parameters directly to the diffusion pipeline without model-specific transformation:
-
-- **Default values**: When parameters are not specified, the underlying model uses its own defaults
-- **Pass-through design**: User-provided values are forwarded directly to the diffusion engine
-- **Minimal validation**: Only basic type checking and range validation at the API level
-
-### Parameter Compatibility
-
-The API passes parameters directly to the diffusion pipeline without model-specific validation.
-
-- Unsupported parameters may be silently ignored by the model
-- Incompatible values will result in errors from the underlying pipeline
-- Recommended values vary by model - consult model documentation
-
-**Best Practice:** Start with the model's recommended parameters, then adjust based on your needs.
-
-## Error Responses
-
-### 400 Bad Request
-
-Invalid parameters (e.g., model mismatch):
-
-```json
-{
-  "detail": "Invalid size format: '1024x'. Expected format: 'WIDTHxHEIGHT' (e.g., '1024x1024')."
-}
-```
-
-### 422 Unprocessable Entity
-
-Validation errors (missing required fields):
-
-```json
-{
-  "detail": [
-    {
-      "loc": ["body", "prompt"],
-      "msg": "field required",
-      "type": "value_error.missing"
-    }
-  ]
-}
-```
-
-### 503 Service Unavailable
-
-Diffusion engine not initialized:
-
-```json
-{
-  "detail": "Diffusion engine not initialized. Start server with a diffusion model."
-}
-```
-
-## Troubleshooting
-
-### Server Not Running
-
-```bash
-# Check if server is responding
-curl http://localhost:8000/v1/images/generations \
-  -H "Content-Type: application/json" \
-  -d '{"prompt": "test"}'
-```
-
-### Out of Memory
-
-If you encounter OOM errors:
-1. Reduce image size: `"size": "512x512"`
-2. Reduce inference steps: `"num_inference_steps": 25`
-3. Generate fewer images: `"n": 1`
-
-## Testing
-
-Run the test suite to verify functionality:
-
-```bash
-# All image generation tests
-pytest tests/entrypoints/openai_api/test_image_server.py -v
-
-# Specific test
-pytest tests/entrypoints/openai_api/test_image_server.py::test_generate_single_image -v
-```
-
-## Development
-
-Enable debug logging to see prompts and generation details:
-
-```bash
-vllm serve Qwen/Qwen-Image --omni \
-  --uvicorn-log-level debug
-```

docs/usage/faq.md

@@ -12,10 +12,6 @@ sudo apt update
 sudo apt install ffmpeg
 ```
 
-> Q: I see GPU OOM or "free memory is less than desired GPU memory utilization" errors. How can I fix it?
-
-A: Refer to [GPU memory calculation and configuration](../configuration/gpu_memory_utilization.md) for guidance on tuning `gpu_memory_utilization` and related settings.
-
 > Q: I encounter some bugs or CI problems, which is urgent. How can I solve it?
 
 A: At first, you can check current [issues](https://github.com/vllm-project/vllm-omni/issues) to find possible solutions. If none of these satisfy your demand and it is urgent, please find these [volunteers](https://docs.vllm.ai/projects/vllm-omni/en/latest/community/volunteers/) for help.

docs/user_guide/diffusion/cache_dit_acceleration.md

@@ -1,227 +0,0 @@
-# Cache-DiT Acceleration Guide
-
-This guide explains how to use cache-dit acceleration in vLLM-Omni to speed up diffusion model inference.
-
-## Overview
-
-Cache-dit is a library that accelerates diffusion transformer models through intelligent caching mechanisms. It supports multiple acceleration techniques that can be combined for optimal performance:
-
-- **DBCache**: Dual Block Cache for reducing redundant computations
-- **TaylorSeer**: Taylor expansion-based forecasting for faster inference
-- **SCM**: Step Computation Masking for selective step computation
-
-## Quick Start
-
-### Basic Usage
-
-Enable cache-dit acceleration by simply setting `cache_backend="cache_dit"`. Cache-dit will use its recommended default parameters:
-
-```python
-from vllm_omni.entrypoints.omni import Omni
-
-# Simplest way: just enable cache-dit with default parameters
-omni = Omni(
-    model="Qwen/Qwen-Image",
-    cache_backend="cache_dit",
-)
-
-images = omni.generate(
-    "a beautiful landscape",
-    num_inference_steps=50,
-)
-```
-
-**Default Parameters**: When `cache_config` is not provided, cache-dit uses optimized default values. See the [Configuration Reference](#configuration-reference) section for a complete list of all parameters and their default values.
-
-### Custom Configuration
-
-To customize cache-dit settings, provide a `cache_config` dictionary, for example:
-
-```python
-omni = Omni(
-    model="Qwen/Qwen-Image",
-    cache_backend="cache_dit",
-    cache_config={
-        "Fn_compute_blocks": 1,
-        "Bn_compute_blocks": 0,
-        "max_warmup_steps": 4,
-        "residual_diff_threshold": 0.12,
-    },
-)
-```
-
-## Online Serving (OpenAI-Compatible)
-
-Enable Cache-DiT for online serving by passing `--cache-backend cache_dit` when starting the server:
-
-```bash
-# Use Cache-DiT default (recommended) parameters
-vllm serve Qwen/Qwen-Image --omni --port 8091 --cache-backend cache_dit
-```
-
-To customize Cache-DiT settings for online serving, pass a JSON string via `--cache-config`:
-
-```bash
-vllm serve Qwen/Qwen-Image --omni --port 8091 \
-  --cache-backend cache_dit \
-  --cache-config '{"Fn_compute_blocks": 1, "Bn_compute_blocks": 0, "max_warmup_steps": 4, "residual_diff_threshold": 0.12}'
-```
-
-## Acceleration Methods
-
-For comprehensive illustration, please view cache-dit [User_Guide](https://github.com/vipshop/cache-dit/blob/main/docs/User_Guide.md)
-
-### 1. DBCache (Dual Block Cache)
-
-DBCache intelligently caches intermediate transformer block outputs when the residual differences between consecutive steps are small, reducing redundant computations without sacrificing quality.
-
-**Key Parameters**:
-
-- `Fn_compute_blocks` (int, default: 1): Number of **first n** transformer blocks used to compute stable feature differences. Higher values provide more accurate caching decisions but increase computation.
-- `Bn_compute_blocks` (int, default: 0): Number of **last n** transformer blocks used for additional fusion. These blocks act as an auto-scaler for approximate hidden states.
-- `max_warmup_steps` (int, default: 4): Number of initial steps where caching is disabled to ensure the model learns sufficient features before caching begins. Optimized for few-step distilled models.
-- `residual_diff_threshold` (float, default: 0.24): Threshold for residual difference. Higher values lead to faster performance but may reduce precision. Default uses a relatively higher threshold for more aggressive caching.
-- `max_cached_steps` (int, default: -1): Maximum number of cached steps. Set to -1 for unlimited caching.
-- `max_continuous_cached_steps` (int, default: 3): Maximum number of consecutive cached steps. Limits consecutive caching to prevent precision degradation.
-
-**Example Configuration**:
-
-```python
-cache_config={
-    "Fn_compute_blocks": 8,      # Use first 8 blocks for difference computation
-    "Bn_compute_blocks": 0,       # No additional fusion blocks
-    "max_warmup_steps": 8,        # Cache after 8 warmup steps
-    "residual_diff_threshold": 0.12,  # Higher threshold for faster inference
-    "max_cached_steps": -1,        # No limit on cached steps
-}
-```
-
-**Performance Tips**:
-
-- Default `Fn_compute_blocks=1` works well for most cases. Increase to 8-12 for larger models or when more accuracy is needed
-- Increase `residual_diff_threshold` (e.g., 0.12-0.15) for faster inference with slight quality trade-off, or decrease from default 0.24 for higher quality
-- Default `max_warmup_steps=4` is optimized for few-step models. Increase to 6-8 for more steps if needed
-
-### 2. TaylorSeer
-
-TaylorSeer uses Taylor expansion to forecast future hidden states, allowing the model to skip some computation steps while maintaining quality.
-
-**Key Parameters**:
-
-- `enable_taylorseer` (bool, default: False): Enable TaylorSeer acceleration
-- `taylorseer_order` (int, default: 1): Order of Taylor expansion. Higher orders provide better accuracy but require more computation.
-
-**Example Configuration**:
-
-```python
-cache_config={
-    "enable_taylorseer": True,
-    "taylorseer_order": 1,  # First-order Taylor expansion
-}
-```
-
-**Performance Tips**:
-
-- Use `taylorseer_order=1` for most cases (good balance of speed and quality)
-- Combine with DBCache for maximum acceleration
-- Higher orders (2-3) may improve quality but reduce speed gains
-
-### 3. SCM (Step Computation Masking)
-
-SCM allows you to specify which steps must be computed and which can use cached results, similar to LeMiCa/EasyCache style acceleration.
-
-**Key Parameters**:
-
-- `scm_steps_mask_policy` (str | None, default: None): Predefined mask policy. Options:
-  - `None`: SCM disabled (default)
-  - `"slow"`: More compute steps, higher quality (18 compute steps out of 28)
-  - `"medium"`: Balanced (15 compute steps out of 28)
-  - `"fast"`: More cache steps, faster inference (11 compute steps out of 28)
-  - `"ultra"`: Maximum speed (8 compute steps out of 28)
-- `scm_steps_policy` (str, default: "dynamic"): Policy for cached steps:
-  - `"dynamic"`: Use dynamic cache for masked steps (recommended)
-  - `"static"`: Use static cache for masked steps
-
-**Example Configuration**:
-
-```python
-cache_config={
-    "scm_steps_mask_policy": "medium",  # Balanced speed/quality
-    "scm_steps_policy": "dynamic",      # Use dynamic cache
-}
-```
-
-**Performance Tips**:
-
-- SCM is disabled by default (`scm_steps_mask_policy=None`). Enable it by setting a policy value if you need additional acceleration
-- Start with `"medium"` policy and adjust based on quality requirements
-- Use `"fast"` or `"ultra"` for maximum speed when quality can be slightly compromised
-- `"dynamic"` policy generally provides better quality than `"static"`
-- SCM mask is automatically regenerated when `num_inference_steps` changes during inference
-
-## Configuration Reference
-
-### DiffusionCacheConfig Parameters
-
-| Parameter | Type | Default | Description |
-|-----------|------|---------|-------------|
-| `Fn_compute_blocks` | int | 1 | First n blocks for difference computation (optimized for single-transformer models) |
-| `Bn_compute_blocks` | int | 0 | Last n blocks for fusion |
-| `max_warmup_steps` | int | 4 | Steps before caching starts (optimized for few-step distilled models) |
-| `max_cached_steps` | int | -1 | Max cached steps (-1 = unlimited) |
-| `max_continuous_cached_steps` | int | 3 | Max consecutive cached steps (prevents precision degradation) |
-| `residual_diff_threshold` | float | 0.24 | Residual difference threshold (higher for more aggressive caching) |
-| `num_inference_steps` | int \| None | None | Initial inference steps for SCM mask generation (optional, auto-refreshed during inference) |
-| `enable_taylorseer` | bool | False | Enable TaylorSeer acceleration (not suitable for few-step distilled models) |
-| `taylorseer_order` | int | 1 | Taylor expansion order |
-| `scm_steps_mask_policy` | str \| None | None | SCM mask policy (None, "slow", "medium", "fast", "ultra") |
-| `scm_steps_policy` | str | "dynamic" | SCM computation policy ("dynamic" or "static") |
-
-## Example: Accelerate Text-to-Image Generation with CacheDiT
-
-See `examples/offline_inference/text_to_image/text_to_image.py` for a complete working example with cache-dit acceleration.
-
-```bash
-# Enable cache-dit with hybrid acceleration
-cd examples/offline_inference/text_to_image
-python text_to_image.py \
-    --model Qwen/Qwen-Image \
-    --prompt "a cup of coffee on the table" \
-    --cache_backend cache_dit \
-    --num_inference_steps 50
-```
-
-
-The script uses cache-dit acceleration with a hybrid configuration combining DBCache, SCM, and TaylorSeer:
-
-```python
-omni = Omni(
-    model="Qwen/Qwen-Image",
-    cache_backend="cache_dit",
-    cache_config={
-        # Scheme: Hybrid DBCache + SCM + TaylorSeer
-        # DBCache
-        "Fn_compute_blocks": 8,
-        "Bn_compute_blocks": 0,
-        "max_warmup_steps": 4,
-        "residual_diff_threshold": 0.12,
-        # TaylorSeer
-        "enable_taylorseer": True,
-        "taylorseer_order": 1,
-        # SCM
-        "scm_steps_mask_policy": "fast",  # Set to None to disable SCM
-        "scm_steps_policy": "dynamic",
-    },
-)
-```
-
-You can customize the configuration by modifying the `cache_config` dictionary to use only specific methods (e.g., DBCache only, DBCache + SCM, etc.) based on your quality and speed requirements.
-
-To test another model, you can modify `--model` with the target model identifier like `Tongyi-MAI/Z-Image-Turbo` and update `cache_config` according the model architecture (e.g., number of transformer blocks).
-
-
-## Additional Resources
-
-- [Cache-DiT User Guide](https://github.com/vipshop/cache-dit/blob/main/docs/User_Guide.md)
-- [Cache-DiT Benchmark](https://github.com/vipshop/cache-dit/tree/main/bench)
-- [DBCache Technical Details](https://github.com/vipshop/cache-dit/blob/main/docs/DBCache.md)

docs/user_guide/diffusion/cpu_offload_diffusion.md

@@ -1,29 +0,0 @@
-# CPU Offloading for Diffusion Model
-
-## Overview
-CPU offload lets the diffusion worker move large model components between GPU and CPU memory on demand. It keeps the DiT transformer resident on GPU only while it is actively running, and swaps it out when encoders modules need the device. This reduces peak VRAM usage so bigger checkpoints run on smaller GPUs, or multiple requests can share the same GPU.
-
-## Execution Model
-1. Text encoders run on GPU while the DiT transformer is offloaded to CPU.
-2. Before denoising, weights are prefetched back to GPU, honoring pinned-memory copies for speed.
-3. After the diffusion step, the transformer returns to CPU and the process repeats as needed.
-
-Transfers use pinned host buffers, and the worker coordinates swaps via mutex-style hooks so components never compete for memory.
-
-## Configuration
-You can enable CPU offload in two ways:
-
-- **Python API**: set `enable_cpu_offload=True`.
-
-```python
-from vllm_omni import Omni
-
-if __name__ == "__main__":
-
-    m = Omni(model="Qwen/Qwen-Image",enable_cpu_offload=True)
-```
-
-- **CLI**: pass `--enable-cpu-offload` to the diffusion service entrypoint.
-
-## Known Limitations
-- Cold start latency increases for over one minute for some models(e.g., Qwen-Image)

docs/user_guide/diffusion/parallelism_acceleration.md

@@ -1,404 +0,0 @@
-# Parallelism Acceleration Guide
-
-This guide includes how to use parallelism methods in vLLM-Omni to speed up diffusion model inference as well as reduce the memory requirement on each device.
-
-## Overview
-
-The following parallelism methods are currently supported in vLLM-Omni:
-
-1. DeepSpeed Ulysses Sequence Parallel (DeepSpeed Ulysses-SP) ([arxiv paper](https://arxiv.org/pdf/2309.14509)): Ulysses-SP splits the input along the sequence dimension and uses all-to-all communication to allow each device to compute only a subset of attention heads.
-
-2. [Ring-Attention](#ring-attention) - splits the input along the sequence dimension and uses ring-based P2P communication to accumulate attention results, keeping the sequence dimension sharded
-
-3. Classifier-Free-Guidance Parallel (CFG-Parallel): CFG-Parallel runs the positive/negative prompts of classifier-free guidance (CFG) on different devices, then merges on a single device to perform the scheduler step.
-
-4. [Tensor Parallelism](#tensor-parallelism): Tensor parallelism shards model weights across devices. This can reduce per-GPU memory usage. Note that for diffusion models we currently shard the majority of layers within the DiT.
-
-The following table shows which models are currently supported by parallelism method:
-
-### ImageGen
-
-| Model | Model Identifier | Ulysses-SP | Ring-SP | CFG-Parallel | Tensor-Parallel |
-|-------|------------------|------------|---------|--------------|--------------------------|
-| **LongCat-Image** | `meituan-longcat/LongCat-Image` | ✅ | ✅ | ❌ | ❌ |
-| **LongCat-Image-Edit** | `meituan-longcat/LongCat-Image-Edit` | ✅ | ✅ | ❌ | ❌ |
-| **Ovis-Image** | `OvisAI/Ovis-Image` | ❌ | ❌ | ❌ | ❌ |
-| **Qwen-Image** | `Qwen/Qwen-Image` | ✅ | ✅ | ✅ | ❌ |
-| **Qwen-Image-Edit** | `Qwen/Qwen-Image-Edit` | ✅ | ✅ | ✅ | ❌ |
-| **Qwen-Image-Edit-2509** | `Qwen/Qwen-Image-Edit-2509` | ✅ | ✅ | ✅ | ❌ |
-| **Qwen-Image-Layered** | `Qwen/Qwen-Image-Layered` | ✅ | ✅ | ✅ | ❌ |
-| **Z-Image** | `Tongyi-MAI/Z-Image-Turbo` | ❌ | ❌ | ❌ | ✅ (TP=2 only) |
-| **Stable-Diffusion3.5** | `stabilityai/stable-diffusion-3.5` | ❌ | ❌ | ❌ | ❌ |
-
-!!! note "Why Z-Image is TP=2 only"
-    Z-Image Turbo is currently limited to `tensor_parallel_size` of **1 or 2** due to model shape divisibility constraints.
-    For example, the model has `n_heads=30` and a final projection out dimension of `64`, so valid TP sizes must divide both 30 and 64; the only common divisors are **1 and 2**.
-
-### VideoGen
-
-| Model | Model Identifier | Ulysses-SP | Ring-SP | Tensor-Parallel |
-|-------|------------------|------------|---------|--------------------------|
-| **Wan2.2** | `Wan-AI/Wan2.2-T2V-A14B-Diffusers` | ❌ | ❌ | ❌ |
-
-### Tensor Parallelism
-
-Tensor parallelism splits model parameters across GPUs. In vLLM-Omni, tensor parallelism is configured via `DiffusionParallelConfig.tensor_parallel_size`.
-
-#### Offline Inference
-
-```python
-from vllm_omni import Omni
-from vllm_omni.diffusion.data import DiffusionParallelConfig
-
-omni = Omni(
-    model="Tongyi-MAI/Z-Image-Turbo",
-    parallel_config=DiffusionParallelConfig(tensor_parallel_size=2),
-)
-
-outputs = omni.generate(
-    prompt="a cat reading a book",
-    num_inference_steps=9,
-    width=512,
-    height=512,
-)
-```
-
-### Sequence Parallelism
-
-#### Ulysses-SP
-
-##### Offline Inference
-
-An example of offline inference script using [Ulysses-SP](https://arxiv.org/pdf/2309.14509) is shown below:
-```python
-from vllm_omni import Omni
-from vllm_omni.diffusion.data import DiffusionParallelConfig
-ulysses_degree = 2
-
-omni = Omni(
-    model="Qwen/Qwen-Image",
-    parallel_config=DiffusionParallelConfig(ulysses_degree=2)
-)
-
-outputs = omni.generate(prompt="A cat sitting on a windowsill", num_inference_steps=50, width=2048, height=2048)
-```
-
-See `examples/offline_inference/text_to_image/text_to_image.py` for a complete working example.
-
-##### Online Serving
-
-You can enable Ulysses-SP in online serving for diffusion models via `--usp`:
-
-```bash
-# Text-to-image (requires >= 2 GPUs)
-vllm serve Qwen/Qwen-Image --omni --port 8091 --usp 2
-```
-
-##### Benchmarks
-!!! note "Benchmark Disclaimer"
-    These benchmarks are provided for **general reference only**. The configurations shown use default or common parameter settings and have not been exhaustively optimized for maximum performance. Actual performance may vary based on:
-
-    - Specific model and use case
-    - Hardware configuration
-    - Careful parameter tuning
-    - Different inference settings (e.g., number of steps, image resolution)
-
-
-To measure the parallelism methods, we run benchmarks with **Qwen/Qwen-Image** model generating images (**2048x2048** as long sequence input) with 50 inference steps. The hardware devices are NVIDIA H800 GPUs. `sdpa` is the attention backends.
-
-| Configuration | Ulysses degree |Generation Time | Speedup |
-|---------------|----------------|---------|---------|
-| **Baseline (diffusers)** | - | 112.5s | 1.0x |
-| Ulysses-SP  |  2  |  65.2s | 1.73x |
-| Ulysses-SP  |  4  | 39.6s | 2.84x |
-| Ulysses-SP  |  8  | 30.8s | 3.65x |
-
-#### Ring-Attention
-
-Ring-Attention ([arxiv paper](https://arxiv.org/abs/2310.01889)) splits the input along the sequence dimension and uses ring-based P2P communication to accumulate attention results. Unlike Ulysses-SP which uses all-to-all communication, Ring-Attention keeps the sequence dimension sharded throughout the computation and circulates Key/Value blocks through a ring topology.
-
-##### Offline Inference
-
-An example of offline inference script using Ring-Attention is shown below:
-```python
-from vllm_omni import Omni
-from vllm_omni.diffusion.data import DiffusionParallelConfig
-ring_degree = 2
-
-omni = Omni(
-    model="Qwen/Qwen-Image",
-    parallel_config=DiffusionParallelConfig(ring_degree=2)
-)
-
-outputs = omni.generate(prompt="A cat sitting on a windowsill", num_inference_steps=50, width=2048, height=2048)
-```
-
-See `examples/offline_inference/text_to_image/text_to_image.py` for a complete working example.
-
-
-##### Online Serving
-
-You can enable Ring-Attention in online serving for diffusion models via `--ring`:
-
-```bash
-# Text-to-image (requires >= 2 GPUs)
-vllm serve Qwen/Qwen-Image --omni --port 8091 --ring 2
-```
-
-##### Benchmarks
-!!! note "Benchmark Disclaimer"
-    These benchmarks are provided for **general reference only**. The configurations shown use default or common parameter settings and have not been exhaustively optimized for maximum performance. Actual performance may vary based on:
-
-    - Specific model and use case
-    - Hardware configuration
-    - Careful parameter tuning
-    - Different inference settings (e.g., number of steps, image resolution)
-
-
-To measure the parallelism methods, we run benchmarks with **Qwen/Qwen-Image** model generating images (**1024x1024** as long sequence input) with 50 inference steps. The hardware devices are NVIDIA A100 GPUs. `flash_attn` is the attention backends.
-
-| Configuration | Ring degree |Generation Time | Speedup |
-|---------------|----------------|---------|---------|
-| **Baseline (diffusers)** | - | 45.2s | 1.0x |
-| Ring-Attention  |  2  |  29.9s | 1.51x |
-| Ring-Attention  |  4  | 23.3s | 1.94x |
-
-
-#### Hybrid Ulysses + Ring
-
-You can combine both Ulysses-SP and Ring-Attention for larger scale parallelism. The total sequence parallel size equals `ulysses_degree × ring_degree`.
-
-##### Offline Inference
-
-```python
-from vllm_omni import Omni
-from vllm_omni.diffusion.data import DiffusionParallelConfig
-
-# Hybrid: 2 Ulysses × 2 Ring = 4 GPUs total
-omni = Omni(
-    model="Qwen/Qwen-Image",
-    parallel_config=DiffusionParallelConfig(ulysses_degree=2, ring_degree=2)
-)
-
-outputs = omni.generate(prompt="A cat sitting on a windowsill", num_inference_steps=50, width=2048, height=2048)
-```
-
-##### Online Serving
-
-```bash
-# Text-to-image (requires >= 4 GPUs)
-vllm serve Qwen/Qwen-Image --omni --port 8091 --usp 2 --ring 2
-```
-
-##### Benchmarks
-!!! note "Benchmark Disclaimer"
-    These benchmarks are provided for **general reference only**. The configurations shown use default or common parameter settings and have not been exhaustively optimized for maximum performance. Actual performance may vary based on:
-
-    - Specific model and use case
-    - Hardware configuration
-    - Careful parameter tuning
-    - Different inference settings (e.g., number of steps, image resolution)
-
-
-To measure the parallelism methods, we run benchmarks with **Qwen/Qwen-Image** model generating images (**1024x1024** as long sequence input) with 50 inference steps. The hardware devices are NVIDIA A100 GPUs. `flash_attn` is the attention backends.
-
-| Configuration | Ulysses degree | Ring degree | Generation Time | Speedup |
-|---------------|----------------|-------------|-----------------|---------|
-| **Baseline (diffusers)** | - | - | 45.2s | 1.0x |
-| Hybrid Ulysses + Ring  |  2  |  2  |  24.3s | 1.87x |
-
-
-##### How to parallelize a new model
-
-If a diffusion model has been deployed in vLLM-Omni and supports single-card inference, you can refer to the following instructions to parallelize it with [Ulysses-SP](https://arxiv.org/pdf/2309.14509).
-
-
-This section uses **Qwen-Image** (`QwenImageTransformer2DModel`) as the reference implementation. Qwen-Image is a **dual-stream** transformer (text + image) that performs **joint attention** across the concatenated sequences. Because of that, when enabling sequence parallel you typically:
-
-- Chunk **image tokens** (`hidden_states`) across SP ranks along the **sequence dimension**.
-- Keep **text embeddings** (`encoder_hidden_states`) **replicated** on all SP ranks for correctness (unless you implement full joint-SP semantics and explicitly split text too).
-- Chunk **image RoPE freqs** to match the chunked image tokens.
-- `all_gather` the final output back along the sequence dimension.
-
-First, add the sequence-parallel helpers and (for Qwen-Image) the forward-context flag. Then, in the transformer's `forward()`:
-
-- Chunk `hidden_states` by SP world size.
-- Set `get_forward_context().split_text_embed_in_sp = False` because Qwen-Image uses joint attention and we would use a full text embedding in each rank.
-- After `pos_embed`, chunk `img_freqs` on `dim=0` (token axis) to match the chunked image tokens; only chunk `txt_freqs` if you explicitly split text embeddings in SP.
-
-Taking `vllm_omni/diffusion/models/qwen_image/qwen_image_transformer.py` as an example:
-
-```diff
-from vllm_omni.diffusion.distributed.parallel_state import (
-    get_sequence_parallel_rank,
-    get_sequence_parallel_world_size,
-    get_sp_group,
-)
-from vllm_omni.diffusion.forward_context import get_forward_context
-
-class QwenImageTransformer2DModel(...):
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor = None,
-        encoder_hidden_states_mask: torch.Tensor = None,
-        timestep: torch.LongTensor = None,
-        img_shapes: list[tuple[int, int, int]] | None = None,
-        txt_seq_lens: list[int] | None = None,
-        ...
-    ):
-+       if self.parallel_config.sequence_parallel_size > 1:
-+           # Chunk image tokens along sequence dimension.
-+           hidden_states = torch.chunk(
-+               hidden_states,
-+               get_sequence_parallel_world_size(),
-+               dim=-2,
-+           )[get_sequence_parallel_rank()]
-+
-+           # Qwen-Image uses *dual-stream* (text + image) and runs *joint attention*.
-+           # Text embeddings should be replicated across SP ranks for correctness.
-+           get_forward_context().split_text_embed_in_sp = False
-
-        hidden_states = self.img_in(hidden_states)
-
-        ...
-        image_rotary_emb = self.pos_embed(img_shapes, txt_seq_lens, device=hidden_states.device)
-
-+       def get_rotary_emb_chunk(freqs):
-+           return torch.chunk(freqs, get_sequence_parallel_world_size(), dim=0)[
-+               get_sequence_parallel_rank()
-+           ]
-+
-+       if self.parallel_config.sequence_parallel_size > 1:
-+           img_freqs, txt_freqs = image_rotary_emb
-+           img_freqs = get_rotary_emb_chunk(img_freqs)
-+           if get_forward_context().split_text_embed_in_sp:
-+               txt_freqs = get_rotary_emb_chunk(txt_freqs)
-+           image_rotary_emb = (img_freqs, txt_freqs)
-```
-
-Next, at the end of the `forward()` function, call `get_sp_group().all_gather` to gather the chunked outputs across devices and concatenate them along the sequence dimension (matching the earlier `dim=-2` chunking):
-
-```diff
-class QwenImageTransformer2DModel(...):
-    def forward(...):
-        ...
-        hidden_states = self.norm_out(hidden_states, temb)
-        output = self.proj_out(hidden_states)
-
-+       if self.parallel_config.sequence_parallel_size > 1:
-+           output = get_sp_group().all_gather(output, dim=-2)
-        return Transformer2DModelOutput(sample=output)
-```
-
-Finally, you can set the parallel configuration and pass it to `Omni` and start parallel inference with:
-```diff
-from vllm_omni import Omni
-+from vllm_omni.diffusion.data import DiffusionParallelConfig
-ulysses_degree = 2
-
-omni = Omni(
-    model="Qwen/Qwen-Image",
-+    parallel_config=DiffusionParallelConfig(ulysses_degree=2)
-)
-
-outputs = omni.generate(prompt="A cat sitting on a windowsill", num_inference_steps=50)
-```
-
-
-### CFG-Parallel
-
-##### Offline Inference
-
-CFG-Parallel is enabled through `DiffusionParallelConfig(cfg_parallel_size=...)`. The recommended configuration is `cfg_parallel_size=2` (one rank for the positive branch and one rank for the negative branch).
-
-An example of offline inference using CFG-Parallel (image-to-image) is shown below:
-
-```python
-from vllm_omni import Omni
-from vllm_omni.diffusion.data import DiffusionParallelConfig
-
-omni = Omni(
-    model="Qwen/Qwen-Image-Edit",
-    parallel_config=DiffusionParallelConfig(cfg_parallel_size=2),
-)
-
-outputs = omni.generate(
-    prompt="turn this cat to a dog",
-    negative_prompt="low quality, blurry",
-    true_cfg_scale=4.0,
-    pil_image=input_image,
-    num_inference_steps=50,
-)
-```
-
-Notes:
-
-- CFG-Parallel is only effective when **true CFG** is enabled (i.e., `true_cfg_scale > 1` and a `negative_prompt` is provided).
-
-#### How to parallelize a pipeline
-
-This section describes how to add CFG-Parallel to a diffusion **pipeline**. We use the Qwen-Image pipeline (`vllm_omni/diffusion/models/qwen_image/pipeline_qwen_image.py`) as the reference implementation.
-
-In `QwenImagePipeline`, each diffusion step runs two denoiser forward passes sequentially:
-
-- positive (prompt-conditioned)
-- negative (negative-prompt-conditioned)
-
-CFG-Parallel assigns these two branches to different ranks in the **CFG group** and synchronizes the results.
-
-Below is an example of CFG-Parallel implementation:
-
-```python
-def diffuse(
-        self,
-        ...
-        ):
-    # Enable CFG-parallel: rank0 computes positive, rank1 computes negative.
-    cfg_parallel_ready = do_true_cfg and get_classifier_free_guidance_world_size() > 1
-
-    self.transformer.do_true_cfg = do_true_cfg
-
-    if cfg_parallel_ready:
-        cfg_group = get_cfg_group()
-        cfg_rank = get_classifier_free_guidance_rank()
-
-        if cfg_rank == 0:
-            local_pred = self.transformer(
-                hidden_states=latents,
-                timestep=timestep / 1000,
-                guidance=guidance,
-                encoder_hidden_states_mask=prompt_embeds_mask,
-                encoder_hidden_states=prompt_embeds,
-                img_shapes=img_shapes,
-                txt_seq_lens=txt_seq_lens,
-                attention_kwargs=self.attention_kwargs,
-                return_dict=False,
-            )[0]
-        else:
-            local_pred = self.transformer(
-                hidden_states=latents,
-                timestep=timestep / 1000,
-                guidance=guidance,
-                encoder_hidden_states_mask=negative_prompt_embeds_mask,
-                encoder_hidden_states=negative_prompt_embeds,
-                img_shapes=img_shapes,
-                txt_seq_lens=negative_txt_seq_lens,
-                attention_kwargs=self.attention_kwargs,
-                return_dict=False,
-            )[0]
-
-        gathered = cfg_group.all_gather(local_pred, separate_tensors=True)
-        if cfg_rank == 0:
-            noise_pred = gathered[0]
-            neg_noise_pred = gathered[1]
-            comb_pred = neg_noise_pred + true_cfg_scale * (noise_pred - neg_noise_pred)
-            cond_norm = torch.norm(noise_pred, dim=-1, keepdim=True)
-            noise_norm = torch.norm(comb_pred, dim=-1, keepdim=True)
-            noise_pred = comb_pred * (cond_norm / noise_norm)
-            latents = self.scheduler.step(noise_pred, t, latents, return_dict=False)[0]
-        cfg_group.broadcast(latents, src=0)
-    else:
-        # fallback: run positive then negative sequentially on one rank
-        ...
-```

docs/user_guide/diffusion_acceleration.md

@@ -1,204 +0,0 @@
-# Diffusion Acceleration Overview
-
-vLLM-Omni supports various cache acceleration methods to speed up diffusion model inference with minimal quality degradation. These methods include **cache methods** that intelligently cache intermediate computations to avoid redundant work across diffusion timesteps, and **parallelism methods** that distribute the computation across multiple devices.
-
-## Supported Acceleration Methods
-
-vLLM-Omni currently supports two main cache acceleration backends:
-
-1. **[TeaCache](diffusion/teacache.md)** - Hook-based adaptive caching that caches transformer computations when consecutive timesteps are similar
-2. **[Cache-DiT](diffusion/cache_dit_acceleration.md)** - Library-based acceleration using multiple techniques:
-    - **DBCache** (Dual Block Cache): Caches intermediate transformer block outputs based on residual differences
-    - **TaylorSeer**: Uses Taylor expansion-based forecasting for faster inference
-    - **SCM** (Step Computation Masking): Selectively computes steps based on adaptive masking
-
-Both methods can provide significant speedups (typically **1.5x-2.0x**) while maintaining high output quality.
-
-vLLM-Omni also supports parallelism methods for diffusion models, including:
-
-1. [Ulysses-SP](diffusion/parallelism_acceleration.md#ulysses-sp) - splits the input along the sequence dimension and uses all-to-all communication to allow each device to compute only a subset of attention heads.
-
-2. [Ring-Attention](diffusion/parallelism_acceleration.md#ring-attention) - splits the input along the sequence dimension and uses ring-based P2P communication to accumulate attention results, keeping the sequence dimension sharded.
-
-3. [CFG-Parallel](diffusion/parallelism_acceleration.md#cfg-parallel) - runs the positive/negative prompts of classifier-free guidance (CFG) on different devices, then merges on a single device to perform the scheduler step.
-
-## Quick Comparison
-
-### Cache Methods
-
-| Method | Configuration | Description | Best For |
-|--------|--------------|-------------|----------|
-| **TeaCache** | `cache_backend="tea_cache"` | Simple, adaptive caching with minimal configuration | Quick setup, balanced speed/quality |
-| **Cache-DiT** | `cache_backend="cache_dit"` | Advanced caching with multiple techniques (DBCache, TaylorSeer, SCM) | Maximum acceleration, fine-grained control |
-
-## Supported Models
-
-The following table shows which models are currently supported by each acceleration method:
-
-### ImageGen
-
-| Model | Model Identifier | TeaCache | Cache-DiT | Ulysses-SP | Ring-Attention | CFG-Parallel |
-|-------|------------------|:----------:|:-----------:|:-----------:|:----------------:|:----------------:|
-| **LongCat-Image** | `meituan-longcat/LongCat-Image` | ❌ | ✅ | ❌ | ❌ | ❌ |
-| **LongCat-Image-Edit** | `meituan-longcat/LongCat-Image-Edit` | ❌ | ✅ | ❌ | ❌ | ❌ |
-| **Ovis-Image** | `OvisAI/Ovis-Image` | ❌ | ✅ | ❌ | ❌ | ❌ |
-| **Qwen-Image** | `Qwen/Qwen-Image` | ✅ | ✅ | ✅ | ✅ | ✅ |
-| **Qwen-Image-2512** | `Qwen/Qwen-Image-2512` | ✅ | ✅ | ✅ | ✅ | ✅ |
-| **Qwen-Image-Edit** | `Qwen/Qwen-Image-Edit` | ✅ | ✅ | ✅ | ✅ | ✅ |
-| **Qwen-Image-Edit-2509** | `Qwen/Qwen-Image-Edit-2509` | ✅ | ✅ | ✅ | ✅ | ✅ |
-| **Qwen-Image-Layered** | `Qwen/Qwen-Image-Layered` | ❌ | ✅ | ✅ | ✅ | ✅ |
-| **Z-Image** | `Tongyi-MAI/Z-Image-Turbo` | ❌ | ✅ |❌ | ❌ | ❌ |
-| **Stable-Diffusion3.5** | `stabilityai/stable-diffusion-3.5` | ❌ | ✅ | ❌ | ❌ | ❌ |
-| **Bagel** | `ByteDance-Seed/BAGEL-7B-MoT` | ❌ | ✅ | ❌ | ❌ | ❌ |
-
-### VideoGen
-
-| Model | Model Identifier | TeaCache | Cache-DiT | Ulysses-SP | Ring-Attention |
-|-------|------------------|:--------:|:---------:|:----------:|:--------------:|
-| **Wan2.2** | `Wan-AI/Wan2.2-T2V-A14B-Diffusers` | ❌ | ✅ | ❌ | ❌ |
-
-
-## Performance Benchmarks
-
-The following benchmarks were measured on **Qwen/Qwen-Image** and **Qwen/Qwen-Image-Edit** models generating 1024x1024 images with 50 inference steps:
-
-!!! note "Benchmark Disclaimer"
-    These benchmarks are provided for **general reference only**. The configurations shown use default or common parameter settings and have not been exhaustively optimized for maximum performance. Actual performance may vary based on:
-
-    - Specific model and use case
-    - Hardware configuration
-    - Careful parameter tuning
-    - Different inference settings (e.g., number of steps, image resolution)
-
-    For optimal performance in your specific scenario, we recommend experimenting with different parameter configurations as described in the detailed guides below.
-
-| Model | Cache Backend | Cache Config | Generation Time | Speedup | Notes |
-|-------|---------------|--------------|----------------|---------|-------|
-| **Qwen/Qwen-Image** | None  | None | 20.0s | 1.0x | Baseline (diffusers) |
-| **Qwen/Qwen-Image** | TeaCache | `rel_l1_thresh=0.2` | 10.47s | **1.91x** | Recommended default setting |
-| **Qwen/Qwen-Image** | Cache-DiT | DBCache + TaylorSeer (Fn=1, Bn=0, W=8, TaylorSeer order=1) | 10.8s | **1.85x** | - |
-| **Qwen/Qwen-Image** | Cache-DiT | DBCache + TaylorSeer + SCM (Fn=8, Bn=0, W=4, TaylorSeer order=1, SCM fast) | 14.0s | **1.43x** | - |
-| **Qwen/Qwen-Image-Edit** | None | No acceleration | 51.5s | 1.0x | Baseline (diffusers) |
-| **Qwen/Qwen-Image-Edit** | Cache-DiT | Default (Fn=1, Bn=0, W=4, TaylorSeer disabled, SCM disabled) | 21.6s | **2.38x** | - |
-
-To measure the parallelism methods, we run benchmarks with **Qwen/Qwen-Image** model generating images (**2048x2048** as long sequence input) with 50 inference steps. The hardware devices are NVIDIA H800 GPUs. `sdpa` is the attention backends.
-
-| Configuration | Ulysses degree |Generation Time | Speedup |
-|---------------|----------------|---------|---------|
-| **Baseline (diffusers)** | - | 112.5s | 1.0x |
-| Ulysses-SP  |  2  |  65.2s | 1.73x |
-| Ulysses-SP  |  4  | 39.6s | 2.84x |
-| Ulysses-SP  |  8  | 30.8s | 3.65x |
-
-## Quick Start
-
-### Using TeaCache
-
-```python
-from vllm_omni import Omni
-
-omni = Omni(
-    model="Qwen/Qwen-Image",
-    cache_backend="tea_cache",
-    cache_config={"rel_l1_thresh": 0.2}  # Optional, defaults to 0.2
-)
-
-outputs = omni.generate(prompt="A cat sitting on a windowsill", num_inference_steps=50)
-```
-
-### Using Cache-DiT
-
-```python
-from vllm_omni import Omni
-
-omni = Omni(
-    model="Qwen/Qwen-Image",
-    cache_backend="cache_dit",
-    cache_config={
-        "Fn_compute_blocks": 1,
-        "Bn_compute_blocks": 0,
-        "max_warmup_steps": 8,
-        "enable_taylorseer": True,
-        "taylorseer_order": 1,
-    }
-)
-
-outputs = omni.generate(prompt="A cat sitting on a windowsill", num_inference_steps=50)
-```
-
-### Using Ulysses-SP
-
-Run text-to-image:
-```python
-from vllm_omni import Omni
-from vllm_omni.diffusion.data import DiffusionParallelConfig
-ulysses_degree = 2
-
-omni = Omni(
-    model="Qwen/Qwen-Image",
-    parallel_config=DiffusionParallelConfig(ulysses_degree=ulysses_degree)
-)
-
-outputs = omni.generate(prompt="A cat sitting on a windowsill", num_inference_steps=50, width=2048, height=2048)
-```
-
-
-Run image-to-image:
-```python
-from vllm_omni import Omni
-from vllm_omni.diffusion.data import DiffusionParallelConfig
-ulysses_degree = 2
-
-omni = Omni(
-    model="Qwen/Qwen-Image-Edit",
-    parallel_config=DiffusionParallelConfig(ulysses_degree=ulysses_degree)
-)
-
-outputs = omni.generate(prompt="turn this cat to a dog",
-        pil_image=input_image, num_inference_steps=50)
-```
-
-### Using Ring-Attention
-
-Run text-to-image:
-```python
-from vllm_omni import Omni
-from vllm_omni.diffusion.data import DiffusionParallelConfig
-ring_degree = 2
-
-omni = Omni(
-    model="Qwen/Qwen-Image",
-    parallel_config=DiffusionParallelConfig(ring_degree=2)
-)
-
-outputs = omni.generate(prompt="A cat sitting on a windowsill", num_inference_steps=50, width=2048, height=2048)
-```
-
-### Using CFG-Parallel
-
-Run image-to-image:
-
-CFG-Parallel splits the CFG positive/negative branches across GPUs. Use it when you set a non-trivial `true_cfg_scale`.
-
-```python
-from vllm_omni import Omni
-from vllm_omni.diffusion.data import DiffusionParallelConfig
-cfg_parallel_size = 2
-
-omni = Omni(
-    model="Qwen/Qwen-Image-Edit",
-    parallel_config=DiffusionParallelConfig(cfg_parallel_size=cfg_parallel_size)
-)
-
-outputs = omni.generate(prompt="turn this cat to a dog",
-        pil_image=input_image, num_inference_steps=50, true_cfg_scale=4.0)
-```
-
-## Documentation
-
-For detailed information on each acceleration method:
-
-- **[TeaCache Guide](diffusion/teacache.md)** - Complete TeaCache documentation, configuration options, and best practices
-- **[Cache-DiT Acceleration Guide](diffusion/cache_dit_acceleration.md)** - Comprehensive Cache-DiT guide covering DBCache, TaylorSeer, SCM, and configuration parameters
-- **[Sequence Parallelism](diffusion/parallelism_acceleration.md#sequence-parallelism)** - Guidance on how to set sequence parallelism with configuration.
-- **[CFG-Parallel](diffusion/parallelism_acceleration.md#cfg-parallel)** - Guidance on how to set CFG-Parallel to run positive/negative branches across ranks.

docs/user_guide/examples/offline_inference/image_to_image.md

@@ -1,53 +1,24 @@
-# Image-To-Image
-
-Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/offline_inference/image_to_image>.
+# Qwen-Image-Edit Offline Inference
 
+Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/offline_inference/image_to_image>. Added in PR [#196](https://github.com/vllm-project/vllm-omni/pull/196).
 
 This example edits an input image with `Qwen/Qwen-Image-Edit` using the `image_edit.py` CLI.
 
 ## Local CLI Usage
 
-### Single Image Editing
-
-Download the example image:
-
-```bash
-wget https://vllm-public-assets.s3.us-west-2.amazonaws.com/omni-assets/qwen-bear.png
-```
-
-Then run:
-
 ```bash
 python image_edit.py \
-  --image qwen-bear.png \
+  --image qwen_bear.png \
   --prompt "Let this mascot dance under the moon, surrounded by floating stars and poetic bubbles such as 'Be Kind'" \
   --output output_image_edit.png \
   --num_inference_steps 50 \
   --cfg_scale 4.0
 ```
 
-### Multiple Image Editing (Qwen-Image-Edit-2509)
-
-For multiple image inputs, use `Qwen/Qwen-Image-Edit-2509` or  `Qwen/Qwen-Image-Edit-2511`:
-
-```bash
-python image_edit.py \
-  --model Qwen/Qwen-Image-Edit-2509 \
-  --image img1.png img2.png \
-  --prompt "Combine these images into a single scene" \
-  --output output_image_edit.png \
-  --num_inference_steps 50 \
-  --cfg_scale 4.0 \
-  --guidance_scale 1.0
-```
-
 Key arguments:
-
-- `--model`: model name or path. Use `Qwen/Qwen-Image-Edit-2509` or later for multiple image support.
-- `--image`: path(s) to the source image(s) (PNG/JPG, converted to RGB). Can specify multiple images.
+- `--image`: path to the source image (PNG/JPG, converted to RGB).
 - `--prompt` / `--negative_prompt`: text description (string).
-- `--cfg_scale`: true classifier-free guidance scale (default: 4.0). Classifier-free guidance is enabled by setting cfg_scale > 1 and providing a negative_prompt. Higher guidance scale encourages images closely linked to the text prompt, usually at the expense of lower image quality.
-- `--guidance_scale`: guidance scale for guidance-distilled models (default: 1.0, disabled). Unlike classifier-free guidance (--cfg_scale), guidance-distilled models take the guidance scale directly as an input parameter. Enabled when guidance_scale > 1. Ignored when not using guidance-distilled models.
+- `--cfg_scale`: true CFG scale for Qwen-Image-Edit (quality vs. fidelity).
 - `--num_inference_steps`: diffusion sampling steps (more steps = higher quality, slower).
 - `--output`: path to save the generated PNG.
 
@@ -57,7 +28,3 @@ Key arguments:
     ``````py
     --8<-- "examples/offline_inference/image_to_image/image_edit.py"
     ``````
-??? abstract "run_qwen_image_edit_2511.sh"
-    ``````sh
-    --8<-- "examples/offline_inference/image_to_image/run_qwen_image_edit_2511.sh"
-    ``````

docs/user_guide/examples/offline_inference/image_to_video.md

@@ -1,66 +0,0 @@
-# Image-To-Video
-
-Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/offline_inference/image_to_video>.
-
-
-This example demonstrates how to generate videos from images using Wan2.2 Image-to-Video models with vLLM-Omni's offline inference API.
-
-## Local CLI Usage
-
-### Wan2.2-I2V-A14B-Diffusers (MoE)
-```bash
-python image_to_video.py \
-  --model Wan-AI/Wan2.2-I2V-A14B-Diffusers \
-  --image input.png \
-  --prompt "A cat playing with yarn, smooth motion" \
-  --negative_prompt "<optional quality filter>" \
-  --height 480 \
-  --width 832 \
-  --num_frames 48 \
-  --guidance_scale 5.0 \
-  --guidance_scale_high 6.0 \
-  --num_inference_steps 40 \
-  --boundary_ratio 0.875 \
-  --flow_shift 12.0 \
-  --fps 16 \
-  --output i2v_output.mp4
-```
-
-### Wan2.2-TI2V-5B-Diffusers (Unified)
-```bash
-python image_to_video.py \
-  --model Wan-AI/Wan2.2-TI2V-5B-Diffusers \
-  --image input.png \
-  --prompt "A cat playing with yarn, smooth motion" \
-  --negative_prompt "<optional quality filter>" \
-  --height 480 \
-  --width 832 \
-  --num_frames 48 \
-  --guidance_scale 4.0 \
-  --num_inference_steps 40 \
-  --flow_shift 12.0 \
-  --fps 16 \
-  --output i2v_output.mp4
-```
-
-Key arguments:
-
-- `--model`: Model ID (I2V-A14B for MoE, TI2V-5B for unified T2V+I2V).
-- `--image`: Path to input image (required).
-- `--prompt`: Text description of desired motion/animation.
-- `--height/--width`: Output resolution (auto-calculated from image if not set). Dimensions should be multiples of 16.
-- `--num_frames`: Number of frames (default 81).
-- `--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 (5.0 for 720p, 12.0 for 480p).
-- `--num_inference_steps`: Number of denoising steps (default 50).
-- `--fps`: Frames per second for the saved MP4 (requires `diffusers` export_to_video).
-- `--output`: Path to save the generated video.
-
-## Example materials
-
-??? abstract "image_to_video.py"
-    ``````py
-    --8<-- "examples/offline_inference/image_to_video/image_to_video.py"
-    ``````

docs/user_guide/examples/offline_inference/qwen2_5_omni.md

@@ -1,19 +1,29 @@
-# Qwen2.5-Omni
+# Offline Example of vLLM-Omni for Qwen2.5-Omni
 
 Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/offline_inference/qwen2_5_omni>.
 
 
-## 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.
+## 🛠️ Installation
 
-## Run examples
+Please refer to [README.md](https://github.com/vllm-project/vllm-omni/tree/main/README.md)
+
+## Run examples (Qwen2.5-Omni)
 
 ### Multiple Prompts
+Download dataset from [seed_tts](https://drive.google.com/file/d/1GlSjVfSHkW3-leKKBlfrjuuTGqQ_xaLP/edit). To get the prompt, you can:
+```bash
+tar -xf <Your Download Path>/seedtts_testset.tar
+cp seedtts_testset/en/meta.lst examples/offline_inference/qwen2_5_omni/meta.lst
+python3 examples/offline_inference/qwen2_5_omni/extract_prompts.py \
+  --input examples/offline_inference/qwen2_5_omni/meta.lst \
+  --output examples/offline_inference/qwen2_5_omni/top100.txt \
+  --topk 100
+```
 Get into the example folder
 ```bash
 cd examples/offline_inference/qwen2_5_omni
 ```
-Then run the command below. Note: for processing large volume data, it uses py_generator mode, which will return a python generator from Omni class.
+Then run the command below.
 ```bash
 bash run_multiple_prompts.sh
 ```
@@ -28,14 +38,6 @@ Then run the command below.
 bash run_single_prompt.sh
 ```
 
-### Modality control
-If you want to control output modalities, e.g. only output text, you can run the command below:
-```bash
-python end2end.py --output-wav output_audio \
-                  --query-type mixed_modalities \
-                  --modalities text
-```
-
 #### Using Local Media Files
 The `end2end.py` script supports local media files (audio, video, image) via CLI arguments:
 

docs/user_guide/examples/offline_inference/qwen3_omni.md

@@ -1,19 +1,21 @@
-# Qwen3-Omni
+# Offline Example of vLLM-Omni for Qwen3-Omni
 
 Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/offline_inference/qwen3_omni>.
 
 
-## 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.
+## 🛠️ Installation
 
-## Run examples
+Please refer to [README.md](https://github.com/vllm-project/vllm-omni/tree/main/README.md)
+
+## Run examples (Qwen3-Omni)
 
 ### Multiple Prompts
+Download dataset from [seed_tts](https://drive.google.com/file/d/1GlSjVfSHkW3-leKKBlfrjuuTGqQ_xaLP/edit). For processing dataset please refer to [Qwen2.5-Omni README.md](https://github.com/vllm-project/vllm-omni/tree/main/examples/offline_inference/qwen2_5_omni/README.md)
 Get into the example folder
 ```bash
 cd examples/offline_inference/qwen3_omni
 ```
-Then run the command below. Note: for processing large volume data, it uses py_generator mode, which will return a python generator from Omni class.
+Then run the command below.
 ```bash
 bash run_multiple_prompts.sh
 ```
@@ -31,14 +33,6 @@ If you have not enough memory, you can set thinker with tensor parallel. Just ru
 bash run_single_prompt_tp.sh
 ```
 
-### Modality control
-If you want to control output modalities, e.g. only output text, you can run the command below:
-```bash
-python end2end.py --output-wav output_audio \
-                  --query-type use_audio \
-                  --modalities text
-```
-
 #### Using Local Media Files
 The `end2end.py` script supports local media files (audio, video, image) via command-line arguments:
 
@@ -51,12 +45,6 @@ python end2end.py --query-type use_image --image-path /path/to/image.jpg
 
 # Use local audio file
 python end2end.py --query-type use_audio --audio-path /path/to/audio.wav
-
-# Combine multiple local media files
-python end2end.py --query-type mixed_modalities \
-    --video-path /path/to/video.mp4 \
-    --image-path /path/to/image.jpg \
-    --audio-path /path/to/audio.wav
 ```
 
 If media file paths are not provided, the script will use default assets. Supported query types:
@@ -64,8 +52,6 @@ If media file paths are not provided, the script will use default assets. Suppor
 - `use_image`: Image input
 - `use_audio`: Audio input
 - `text`: Text-only query
-- `multi_audios`: Multiple audio inputs
-- `mixed_modalities`: Combination of video, image, and audio inputs
 
 ### FAQ
 
@@ -93,7 +79,3 @@ sudo apt install ffmpeg
     ``````sh
     --8<-- "examples/offline_inference/qwen3_omni/run_single_prompt_tp.sh"
     ``````
-??? abstract "text_prompts_10.txt"
-    ``````txt
-    --8<-- "examples/offline_inference/qwen3_omni/text_prompts_10.txt"
-    ``````

docs/user_guide/examples/offline_inference/text_to_image.md

@@ -1,44 +1,13 @@
-# Text-To-Image
+# Qwen-Image Offline Inference
 
 Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/offline_inference/text_to_image>.
 
 
-This folder provides several entrypoints for experimenting with `Qwen/Qwen-Image` `Qwen/Qwen-Image-2512` `Tongyi-MAI/Z-Image-Turbo` using vLLM-Omni:
+This folder provides two simple entrypoints for experimenting with `Qwen/Qwen-Image` `Tongyi-MAI/Z-Image-Turbo` using vLLM-Omni:
 
-- `text_to_image.py`: command-line script for single image generation with advanced options.
+- `text_to_image.py`: command-line script for single image generation.
 - `web_demo.py`: lightweight Gradio UI for interactive prompt/seed/CFG exploration.
 
-Note that when you pass in multiple independent prompts, they will be processed sequentially. Batching requests is currently not supported.
-
-## Basic Usage
-
-```python
-from vllm_omni.entrypoints.omni import Omni
-
-if __name__ == "__main__":
-    omni = Omni(model="Qwen/Qwen-Image")
-    prompt = "a cup of coffee on the table"
-    outputs = omni.generate(prompt)
-    images = outputs[0].request_output[0].images
-    images[0].save("coffee.png")
-```
-
-Or put more than one prompt in a request, processing them sequentially.
-
-```python
-from vllm_omni.entrypoints.omni import Omni
-
-if __name__ == "__main__":
-    omni = Omni(model="Qwen/Qwen-Image")
-    prompts = [
-      "a cup of coffee on a table",
-      "a toy dinosaur on a sandy beach",
-      "a fox waking up in bed and yawning",
-    ]
-    outputs = omni.generate(prompts)
-    for i, output in enumerate(outputs):
-      image = output.request_output[0].images[0].save(f"{i}.jpg")
-```
 
 ## Local CLI Usage
 
@@ -65,8 +34,6 @@ Key arguments:
 - `--height/--width`: output resolution (defaults 1024x1024).
 - `--output`: path to save the generated PNG.
 
-> ℹ️ Qwen-Image currently publishes best-effort presets at `1328x1328`, `1664x928`, `928x1664`, `1472x1140`, `1140x1472`, `1584x1056`, and `1056x1584`. Adjust `--height/--width` accordingly for the most reliable outcomes.
-
 ## Web UI Demo
 
 Launch the gradio demo:

docs/user_guide/examples/offline_inference/text_to_video.md

@@ -1,7 +1,6 @@
-# Text-To-Video
-
-Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/offline_inference/text_to_video>.
+# Wan2.2 Text-to-Video Offline Inference
 
+Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/offline_inference/text_to_video>. Added in PR [#202](https://github.com/vllm-project/vllm-omni/pull/202).
 
 The `Wan-AI/Wan2.2-T2V-A14B-Diffusers` pipeline generates short videos from text prompts.
 
@@ -22,7 +21,6 @@ python text_to_video.py \
 ```
 
 Key arguments:
-
 - `--prompt`: text description (string).
 - `--height/--width`: output resolution (defaults 720x1280). Dimensions should align with Wan VAE downsampling (multiples of 8).
 - `--num_frames`: Number of frames (Wan default is 81).
@@ -36,5 +34,5 @@ Key arguments:
 
 ??? abstract "text_to_video.py"
     ``````py
-    --8<-- "examples/offline_inference/text_to_video/text_to_video.py"
+    --8<-- "examples/offline_inference/wan22/text_to_video.py"
     ``````

docs/user_guide/examples/online_serving/gradio_demo.md

@@ -0,0 +1,7 @@
+# Gradio Demo
+
+Source <https://github.com/vllm-project/vllm-omni/blob/main/examples/online_serving/gradio_demo.py>.
+
+``````py
+--8<-- "examples/online_serving/gradio_demo.py"
+``````

docs/user_guide/examples/online_serving/image_to_image.md

@@ -1,240 +0,0 @@
-# Image-To-Image
-
-Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/online_serving/image_to_image>.
-
-
-This example demonstrates how to deploy Qwen-Image-Edit model for online image editing service using vLLM-Omni.
-
-For **multi-image** input editing, use **Qwen-Image-Edit-2509** (QwenImageEditPlusPipeline) and send multiple images in the user message content.
-
-## Start Server
-
-### Basic Start
-
-```bash
-vllm serve Qwen/Qwen-Image-Edit --omni --port 8092
-```
-
-### Multi-Image Edit (Qwen-Image-Edit-2509)
-
-```bash
-vllm serve Qwen/Qwen-Image-Edit-2509 --omni --port 8092
-```
-
-### Start with Parameters
-
-
-Or use the startup script:
-
-```bash
-bash run_server.sh
-```
-
-To serve Qwen-Image-Edit-2509 with the script:
-
-```bash
-MODEL=Qwen/Qwen-Image-Edit-2509 bash run_server.sh
-```
-
-## API Calls
-
-### Method 1: Using curl (Image Editing)
-
-```bash
-# Image editing
-bash run_curl_image_edit.sh input.png "Convert this image to watercolor style"
-
-# Or execute directly
-IMG_B64=$(base64 -w0 input.png)
-
-cat <<EOF > request.json
-{
-  "messages": [{
-    "role": "user",
-    "content": [
-      {"type": "text", "text": "Convert this image to watercolor style"},
-      {"type": "image_url", "image_url": {"url": "data:image/png;base64,$IMG_B64"}}
-    ]
-  }],
-  "extra_body": {
-    "height": 1024,
-    "width": 1024,
-    "num_inference_steps": 50,
-    "guidance_scale": 1,
-    "seed": 42
-  }
-}
-EOF
-
-curl -s http://localhost:8092/v1/chat/completions   -H "Content-Type: application/json"   -d @request.json | jq -r '.choices[0].message.content[0].image_url.url' | cut -d',' -f2 | base64 -d > output.png
-```
-
-### Method 2: Using Python Client
-
-```bash
-python openai_chat_client.py --input input.png --prompt "Convert to oil painting style" --output output.png
-
-# Multi-image editing (Qwen-Image-Edit-2509 server required)
-python openai_chat_client.py --input input1.png input2.png --prompt "Combine these images into a single scene" --output output.png
-```
-
-### Method 3: Using Gradio Demo
-
-```bash
-python gradio_demo.py
-# Visit http://localhost:7861
-```
-
-## Request Format
-
-### Image Editing (Using image_url Format)
-
-```json
-{
-  "messages": [
-    {
-      "role": "user",
-      "content": [
-        {"type": "text", "text": "Convert this image to watercolor style"},
-        {"type": "image_url", "image_url": {"url": "data:image/png;base64,..."}}
-      ]
-    }
-  ]
-}
-```
-
-### Image Editing (Using Simplified image Format)
-
-```json
-{
-  "messages": [
-    {
-      "role": "user",
-      "content": [
-        {"text": "Convert this image to watercolor style"},
-        {"image": "BASE64_IMAGE_DATA"}
-      ]
-    }
-  ]
-}
-```
-
-### Image Editing with Parameters
-
-Use `extra_body` to pass generation parameters:
-
-```json
-{
-  "messages": [
-    {
-      "role": "user",
-      "content": [
-        {"type": "text", "text": "Convert to ink wash painting style"},
-        {"type": "image_url", "image_url": {"url": "data:image/png;base64,..."}}
-      ]
-    }
-  ],
-  "extra_body": {
-    "height": 1024,
-    "width": 1024,
-    "num_inference_steps": 50,
-    "guidance_scale": 7.5,
-    "seed": 42
-  }
-}
-```
-
-### Multi-Image Editing (Qwen-Image-Edit-2509)
-
-Provide multiple images in `content` (order matters):
-
-```json
-{
-  "messages": [
-    {
-      "role": "user",
-      "content": [
-        {"type": "text", "text": "Combine these images into a single scene"},
-        {"type": "image_url", "image_url": {"url": "data:image/png;base64,..."} },
-        {"type": "image_url", "image_url": {"url": "data:image/png;base64,..."} }
-      ]
-    }
-  ]
-}
-```
-
-## Generation Parameters (extra_body)
-
-| Parameter                | Type  | Default | Description                           |
-| ------------------------ | ----- | ------- | ------------------------------------- |
-| `height`                 | int   | None    | Output image height in pixels         |
-| `width`                  | int   | None    | Output image width in pixels          |
-| `size`                   | str   | None    | Output image size (e.g., "1024x1024") |
-| `num_inference_steps`    | int   | 50      | Number of denoising steps             |
-| `guidance_scale`         | float | 7.5     | CFG guidance scale                    |
-| `seed`                   | int   | None    | Random seed (reproducible)            |
-| `negative_prompt`        | str   | None    | Negative prompt                       |
-| `num_outputs_per_prompt` | int   | 1       | Number of images to generate          |
-
-## Response Format
-
-```json
-{
-  "id": "chatcmpl-xxx",
-  "created": 1234567890,
-  "model": "Qwen/Qwen-Image-Edit",
-  "choices": [{
-    "index": 0,
-    "message": {
-      "role": "assistant",
-      "content": [{
-        "type": "image_url",
-        "image_url": {
-          "url": "data:image/png;base64,..."
-        }
-      }]
-    },
-    "finish_reason": "stop"
-  }],
-  "usage": {...}
-}
-```
-
-## Common Editing Instructions Examples
-
-| Instruction                              | Description      |
-| ---------------------------------------- | ---------------- |
-| `Convert this image to watercolor style` | Style transfer   |
-| `Convert the image to black and white`   | Desaturation     |
-| `Enhance the color saturation`           | Color adjustment |
-| `Convert to cartoon style`               | Cartoonization   |
-| `Add vintage filter effect`              | Filter effect    |
-| `Convert daytime scene to nighttime`     | Scene conversion |
-
-## File Description
-
-| File                     | Description                  |
-| ------------------------ | ---------------------------- |
-| `run_server.sh`          | Server startup script        |
-| `run_curl_image_edit.sh` | curl image editing example   |
-| `openai_chat_client.py`  | Python client                |
-| `gradio_demo.py`         | Gradio interactive interface |
-
-## Example materials
-
-??? abstract "gradio_demo.py"
-    ``````py
-    --8<-- "examples/online_serving/image_to_image/gradio_demo.py"
-    ``````
-??? abstract "openai_chat_client.py"
-    ``````py
-    --8<-- "examples/online_serving/image_to_image/openai_chat_client.py"
-    ``````
-??? abstract "run_curl_image_edit.sh"
-    ``````sh
-    --8<-- "examples/online_serving/image_to_image/run_curl_image_edit.sh"
-    ``````
-??? abstract "run_server.sh"
-    ``````sh
-    --8<-- "examples/online_serving/image_to_image/run_server.sh"
-    ``````

docs/user_guide/examples/online_serving/openai_chat_completion_client_for_multimodal_generation.md

@@ -0,0 +1,7 @@
+# OpenAI Chat Completion Client For Multimodal Generation
+
+Source <https://github.com/vllm-project/vllm-omni/blob/main/examples/online_serving/openai_chat_completion_client_for_multimodal_generation.py>.
+
+``````py
+--8<-- "examples/online_serving/openai_chat_completion_client_for_multimodal_generation.py"
+``````

docs/user_guide/examples/online_serving/qwen2_5_omni.md

@@ -1,4 +1,4 @@
-# Qwen2.5-Omni
+# Online serving Example of vLLM-Omni for Qwen2.5-Omni
 
 Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/online_serving/qwen2_5_omni>.
 
@@ -27,7 +27,7 @@ Get into the example folder
 cd examples/online_serving/qwen2_5_omni
 ```
 
-#### Send request via python
+####  Send request via python
 
 ```bash
 python openai_chat_completion_client_for_multimodal_generation.py --query-type mixed_modalities
@@ -35,11 +35,25 @@ python openai_chat_completion_client_for_multimodal_generation.py --query-type m
 
 The Python client supports the following command-line arguments:
 
-- `--query-type` (or `-q`): Query type (default: `mixed_modalities`). Options: `mixed_modalities`, `use_audio_in_video`, `multi_audios`, `text`
-- `--video-path` (or `-v`): Path to local video file or URL. If not provided and query-type uses video, uses default video URL. Supports local file paths (automatically encoded to base64) or HTTP/HTTPS URLs. Example: `--video-path /path/to/video.mp4` or `--video-path https://example.com/video.mp4`
-- `--image-path` (or `-i`): Path to local image file or URL. If not provided and query-type uses image, uses default image URL. Supports local file paths (automatically encoded to base64) or HTTP/HTTPS URLs and common image formats: JPEG, PNG, GIF, WebP. Example: `--image-path /path/to/image.jpg` or `--image-path https://example.com/image.png`
-- `--audio-path` (or `-a`): Path to local audio file or URL. If not provided and query-type uses audio, uses default audio URL. Supports local file paths (automatically encoded to base64) or HTTP/HTTPS URLs and common audio formats: MP3, WAV, OGG, FLAC, M4A. Example: `--audio-path /path/to/audio.wav` or `--audio-path https://example.com/audio.mp3`
-- `--prompt` (or `-p`): Custom text prompt/question. If not provided, uses default prompt for the selected query type. Example: `--prompt "What are the main activities shown in this video?"`
+- `--query-type` (or `-q`): Query type (default: `mixed_modalities`)
+  - Options: `mixed_modalities`, `use_audio_in_video`, `multi_audios`, `text`
+- `--video-path` (or `-v`): Path to local video file or URL
+  - If not provided and query-type uses video, uses default video URL
+  - Supports local file paths (automatically encoded to base64) or HTTP/HTTPS URLs
+  - Example: `--video-path /path/to/video.mp4` or `--video-path https://example.com/video.mp4`
+- `--image-path` (or `-i`): Path to local image file or URL
+  - If not provided and query-type uses image, uses default image URL
+  - Supports local file paths (automatically encoded to base64) or HTTP/HTTPS URLs
+  - Supports common image formats: JPEG, PNG, GIF, WebP
+  - Example: `--image-path /path/to/image.jpg` or `--image-path https://example.com/image.png`
+- `--audio-path` (or `-a`): Path to local audio file or URL
+  - If not provided and query-type uses audio, uses default audio URL
+  - Supports local file paths (automatically encoded to base64) or HTTP/HTTPS URLs
+  - Supports common audio formats: MP3, WAV, OGG, FLAC, M4A
+  - Example: `--audio-path /path/to/audio.wav` or `--audio-path https://example.com/audio.mp3`
+- `--prompt` (or `-p`): Custom text prompt/question
+  - If not provided, uses default prompt for the selected query type
+  - Example: `--prompt "What are the main activities shown in this video?"`
 
 
 For example, to use mixed modalities with all local files:
@@ -59,154 +73,26 @@ python openai_chat_completion_client_for_multimodal_generation.py \
 bash run_curl_multimodal_generation.sh mixed_modalities
 ```
 
-## Modality control
-You can control output modalities to specify which types of output the model should generate. This is useful when you only need text output and want to skip audio generation stages for better performance.
-
-### Supported modalities
-
-| Modalities | Output |
-|------------|--------|
-| `["text"]` | Text only |
-| `["audio"]` | Text + Audio |
-| `["text", "audio"]` | Text + Audio |
-| Not specified | Text + Audio (default) |
-
-### Using curl
-
-#### Text only
-
-```bash
-curl http://localhost:8091/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -d '{
-    "model": "Qwen/Qwen2.5-Omni-7B",
-    "messages": [{"role": "user", "content": "Describe vLLM in brief."}],
-    "modalities": ["text"]
-  }'
-```
-
-#### Text + Audio
-
-```bash
-curl http://localhost:8091/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -d '{
-    "model": "Qwen/Qwen2.5-Omni-7B",
-    "messages": [{"role": "user", "content": "Describe vLLM in brief."}],
-    "modalities": ["audio"]
-  }'
-```
-
-### Using Python client
-
-```bash
-python openai_chat_completion_client_for_multimodal_generation.py \
-    --query-type mixed_modalities \
-    --modalities text
-```
-
-### Using OpenAI Python SDK
-
-#### Text only
-
-```python
-from openai import OpenAI
-
-client = OpenAI(base_url="http://localhost:8091/v1", api_key="EMPTY")
-
-response = client.chat.completions.create(
-    model="Qwen/Qwen2.5-Omni-7B",
-    messages=[{"role": "user", "content": "Describe vLLM in brief."}],
-    modalities=["text"]
-)
-print(response.choices[0].message.content)
-```
-
-#### Text + Audio
-
-```python
-from openai import OpenAI
-
-client = OpenAI(base_url="http://localhost:8091/v1", api_key="EMPTY")
-
-response = client.chat.completions.create(
-    model="Qwen/Qwen2.5-Omni-7B",
-    messages=[{"role": "user", "content": "Describe vLLM in brief."}],
-    modalities=["audio"]
-)
-# Response contains two choices: one with text, one with audio
-print(response.choices[0].message.content)  # Text response
-print(response.choices[1].message.audio)    # Audio response
-```
-
-## Streaming Output
-If you want to enable streaming output, please set the argument as below. The final output will be obtained just after generated by corresponding stage. Now we only support text streaming output. Other modalities can output normally.
-```bash
-python openai_chat_completion_client_for_multimodal_generation.py \
-    --query-type mixed_modalities \
-    --stream
-```
-
 ## Run Local Web UI Demo
 
 This Web UI demo allows users to interact with the model through a web browser.
 
 ### Running Gradio Demo
 
-The Gradio demo connects to a vLLM API server. You have two options:
-
-#### Option 1: One-step Launch Script (Recommended)
-
-The convenience script launches both the vLLM server and Gradio demo together:
+Once vllm and vllm-omni are installed, you can launch the web service built on AsyncOmni by
 
 ```bash
-./run_gradio_demo.sh --model Qwen/Qwen2.5-Omni-7B --server-port 8091 --gradio-port 7861
-```
-
-This script will:
-1. Start the vLLM server in the background
-2. Wait for the server to be ready
-3. Launch the Gradio demo
-4. Handle cleanup when you press Ctrl+C
-
-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)
-- `--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)
-
-#### Option 2: Manual Launch (Two-Step Process)
-
-**Step 1: Launch the vLLM API server**
-
-```bash
-vllm serve Qwen/Qwen2.5-Omni-7B --omni --port 8091
-```
-
-If you have custom stage configs file:
-```bash
-vllm serve Qwen/Qwen2.5-Omni-7B --omni --port 8091 --stage-configs-path /path/to/stage_configs_file
-```
-
-**Step 2: Run the Gradio demo**
-
-In a separate terminal:
-
-```bash
-python gradio_demo.py --model Qwen/Qwen2.5-Omni-7B --api-base http://localhost:8091/v1 --port 7861
+python gradio_demo.py  --model Qwen/Qwen2.5-Omni-7B --port 7861
 ```
 
 Then open `http://localhost:7861/` on your local browser to interact with the web UI.
 
 The gradio script supports the following arguments:
 
-- `--model`: Model name/path (should match the server model)
-- `--api-base`: Base URL for the vLLM API server (default: http://localhost:8091/v1)
+- `--model`: Model name
 - `--ip`: Host/IP for Gradio server (default: 127.0.0.1)
 - `--port`: Port for Gradio server (default: 7861)
+- `--stage-configs-path`: Path to custom stage configs YAML file (optional)
 - `--share`: Share the Gradio demo publicly (creates a public link)
 
 ### FAQ
@@ -231,7 +117,3 @@ sudo apt install ffmpeg
     ``````sh
     --8<-- "examples/online_serving/qwen2_5_omni/run_curl_multimodal_generation.sh"
     ``````
-??? abstract "run_gradio_demo.sh"
-    ``````sh
-    --8<-- "examples/online_serving/qwen2_5_omni/run_gradio_demo.sh"
-    ``````

docs/user_guide/examples/online_serving/qwen3_omni.md

@@ -1,4 +1,4 @@
-# Qwen3-Omni
+# Online serving Example of vLLM-Omni for Qwen3-omni
 
 Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/online_serving/qwen3_omni>.
 
@@ -35,12 +35,26 @@ python openai_chat_completion_client_for_multimodal_generation.py --query-type u
 
 The Python client supports the following command-line arguments:
 
-- `--query-type` (or `-q`): Query type (default: `use_video`). Options: `text`, `use_audio`, `use_image`, `use_video`
+- `--query-type` (or `-q`): Query type (default: `use_video`)
+  - Options: `text`, `use_audio`, `use_image`, `use_video`
 - `--model` (or `-m`): Model name/path (default: `Qwen/Qwen3-Omni-30B-A3B-Instruct`)
-- `--video-path` (or `-v`): Path to local video file or URL. If not provided and query-type is `use_video`, uses default video URL. Supports local file paths (automatically encoded to base64) or HTTP/HTTPS URLs. Example: `--video-path /path/to/video.mp4` or `--video-path https://example.com/video.mp4`
-- `--image-path` (or `-i`): Path to local image file or URL. If not provided and query-type is `use_image`, uses default image URL. Supports local file paths (automatically encoded to base64) or HTTP/HTTPS URLs and common image formats: JPEG, PNG, GIF, WebP. Example: `--image-path /path/to/image.jpg` or `--image-path https://example.com/image.png`
-- `--audio-path` (or `-a`): Path to local audio file or URL. If not provided and query-type is `use_audio`, uses default audio URL. Supports local file paths (automatically encoded to base64) or HTTP/HTTPS URLs and common audio formats: MP3, WAV, OGG, FLAC, M4A. Example: `--audio-path /path/to/audio.wav` or `--audio-path https://example.com/audio.mp3`
-- `--prompt` (or `-p`): Custom text prompt/question. If not provided, uses default prompt for the selected query type. Example: `--prompt "What are the main activities shown in this video?"`
+- `--video-path` (or `-v`): Path to local video file or URL
+  - If not provided and query-type is `use_video`, uses default video URL
+  - Supports local file paths (automatically encoded to base64) or HTTP/HTTPS URLs
+  - Example: `--video-path /path/to/video.mp4` or `--video-path https://example.com/video.mp4`
+- `--image-path` (or `-i`): Path to local image file or URL
+  - If not provided and query-type is `use_image`, uses default image URL
+  - Supports local file paths (automatically encoded to base64) or HTTP/HTTPS URLs
+  - Supports common image formats: JPEG, PNG, GIF, WebP
+  - Example: `--image-path /path/to/image.jpg` or `--image-path https://example.com/image.png`
+- `--audio-path` (or `-a`): Path to local audio file or URL
+  - If not provided and query-type is `use_audio`, uses default audio URL
+  - Supports local file paths (automatically encoded to base64) or HTTP/HTTPS URLs
+  - Supports common audio formats: MP3, WAV, OGG, FLAC, M4A
+  - Example: `--audio-path /path/to/audio.wav` or `--audio-path https://example.com/audio.mp3`
+- `--prompt` (or `-p`): Custom text prompt/question
+  - If not provided, uses default prompt for the selected query type
+  - Example: `--prompt "What are the main activities shown in this video?"`
 
 
 For example, to use a local video file with custom prompt:
@@ -67,154 +81,27 @@ sudo apt update
 sudo apt install ffmpeg
 ```
 
-## Modality control
-You can control output modalities to specify which types of output the model should generate. This is useful when you only need text output and want to skip audio generation stages for better performance.
-
-### Supported modalities
-
-| Modalities | Output |
-|------------|--------|
-| `["text"]` | Text only |
-| `["audio"]` | Text + Audio |
-| `["text", "audio"]` | Text + Audio |
-| Not specified | Text + Audio (default) |
-
-### Using curl
-
-#### Text only
-
-```bash
-curl 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": ["text"]
-  }'
-```
-
-#### Text + Audio
-
-```bash
-curl 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"]
-  }'
-```
-
-### Using Python client
-
-```bash
-python openai_chat_completion_client_for_multimodal_generation.py \
-    --query-type use_image \
-    --modalities text
-```
-
-### Using OpenAI Python SDK
-
-#### Text only
-
-```python
-from openai import OpenAI
-
-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=["text"]
-)
-print(response.choices[0].message.content)
-```
-
-#### Text + Audio
-
-```python
-from openai import OpenAI
-
-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"]
-)
-# Response contains two choices: one with text, one with audio
-print(response.choices[0].message.content)  # Text response
-print(response.choices[1].message.audio)    # Audio response
-```
-
-## Streaming Output
-If you want to enable streaming output, please set the argument as below. The final output will be obtained just after generated by corresponding stage. Now we only support text streaming output. Other modalities can output normally.
-```bash
-python openai_chat_completion_client_for_multimodal_generation.py \
-    --query-type use_image \
-    --stream
-```
-
 ## Run Local Web UI Demo
 
 This Web UI demo allows users to interact with the model through a web browser.
 
 ### Running Gradio Demo
 
-The Gradio demo connects to a vLLM API server. You have two options:
-
-#### Option 1: One-step Launch Script (Recommended)
-
-The convenience script launches both the vLLM server and Gradio demo together:
+Once vllm and vllm-omni are installed, you can launch the web service built on AsyncOmni by
 
 ```bash
-./run_gradio_demo.sh --model Qwen/Qwen3-Omni-30B-A3B-Instruct --server-port 8091 --gradio-port 7861
-```
-
-This script will:
-1. Start the vLLM server in the background
-2. Wait for the server to be ready
-3. Launch the Gradio demo
-4. Handle cleanup when you press Ctrl+C
-
-The script supports the following arguments:
-- `--model`: Model name/path (default: Qwen/Qwen3-Omni-30B-A3B-Instruct)
-- `--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)
-- `--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)
-
-#### Option 2: Manual Launch (Two-Step Process)
-
-**Step 1: Launch the vLLM API server**
-
-```bash
-vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --port 8091
-```
-
-If you have custom stage configs file:
-```bash
-vllm serve Qwen/Qwen3-Omni-30B-A3B-Instruct --omni --port 8091 --stage-configs-path /path/to/stage_configs_file
-```
-
-**Step 2: Run the Gradio demo**
-
-In a separate terminal:
-
-```bash
-python gradio_demo.py --model Qwen/Qwen3-Omni-30B-A3B-Instruct --api-base http://localhost:8091/v1 --port 7861
+python gradio_demo.py  --model Qwen/Qwen3-Omni-30B-A3B-Instruct --port 7861
 ```
 
 Then open `http://localhost:7861/` on your local browser to interact with the web UI.
 
+
 The gradio script supports the following arguments:
 
-- `--model`: Model name/path (should match the server model)
-- `--api-base`: Base URL for the vLLM API server (default: http://localhost:8091/v1)
+- `--model`: Model name
 - `--ip`: Host/IP for Gradio server (default: 127.0.0.1)
 - `--port`: Port for Gradio server (default: 7861)
+- `--stage-configs-path`: Path to custom stage configs YAML file (optional)
 - `--share`: Share the Gradio demo publicly (creates a public link)
 
 ## Example materials
@@ -235,7 +122,3 @@ The gradio script supports the following arguments:
     ``````sh
     --8<-- "examples/online_serving/qwen3_omni/run_curl_multimodal_generation.sh"
     ``````
-??? abstract "run_gradio_demo.sh"
-    ``````sh
-    --8<-- "examples/online_serving/qwen3_omni/run_gradio_demo.sh"
-    ``````

docs/user_guide/examples/online_serving/text_to_image.md

@@ -1,180 +0,0 @@
-# Text-To-Image
-
-Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/online_serving/text_to_image>.
-
-
-This example demonstrates how to deploy Qwen-Image model for online image generation service using vLLM-Omni.
-
-## Start Server
-
-### Basic Start
-
-```bash
-vllm serve Qwen/Qwen-Image --omni --port 8091
-```
-!!! note
-    If you encounter Out-of-Memory (OOM) issues or have limited GPU memory, you can enable VAE slicing and tiling to reduce memory usage, --vae-use-slicing --vae-use-tiling
-
-### Start with Parameters
-
-Or use the startup script:
-
-```bash
-bash run_server.sh
-```
-
-## API Calls
-
-### Method 1: Using curl
-
-```bash
-# Basic text-to-image generation
-bash run_curl_text_to_image.sh
-
-# Or execute directly
-curl -s http://localhost:8091/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -d '{
-    "messages": [
-      {"role": "user", "content": "A beautiful landscape painting"}
-    ],
-    "extra_body": {
-      "height": 1024,
-      "width": 1024,
-      "num_inference_steps": 50,
-      "true_cfg_scale": 4.0,
-      "seed": 42
-    }
-  }' | jq -r '.choices[0].message.content[0].image_url.url' | cut -d',' -f2- | base64 -d > output.png
-```
-
-### Method 2: Using Python Client
-
-```bash
-python openai_chat_client.py --prompt "A beautiful landscape painting" --output output.png
-```
-
-### Method 3: Using Gradio Demo
-
-```bash
-python gradio_demo.py
-# Visit http://localhost:7860
-```
-
-## Request Format
-
-### Simple Text Generation
-
-```json
-{
-  "messages": [
-    {"role": "user", "content": "A beautiful landscape painting"}
-  ]
-}
-```
-
-### Generation with Parameters
-
-Use `extra_body` to pass generation parameters:
-
-```json
-{
-  "messages": [
-    {"role": "user", "content": "A beautiful landscape painting"}
-  ],
-  "extra_body": {
-    "height": 1024,
-    "width": 1024,
-    "num_inference_steps": 50,
-    "true_cfg_scale": 4.0,
-    "seed": 42
-  }
-}
-```
-
-### Multimodal Input (Text + Structured Content)
-
-```json
-{
-  "messages": [
-    {
-      "role": "user",
-      "content": [
-        {"type": "text", "text": "A beautiful landscape painting"}
-      ]
-    }
-  ]
-}
-```
-
-## Generation Parameters (extra_body)
-
-| Parameter                | Type  | Default | Description                    |
-| ------------------------ | ----- | ------- | ------------------------------ |
-| `height`                 | int   | None    | Image height in pixels         |
-| `width`                  | int   | None    | Image width in pixels          |
-| `size`                   | str   | None    | Image size (e.g., "1024x1024") |
-| `num_inference_steps`    | int   | 50      | Number of denoising steps      |
-| `true_cfg_scale`         | float | 4.0     | Qwen-Image CFG scale           |
-| `seed`                   | int   | None    | Random seed (reproducible)     |
-| `negative_prompt`        | str   | None    | Negative prompt                |
-| `num_outputs_per_prompt` | int   | 1       | Number of images to generate   |
-
-## Response Format
-
-```json
-{
-  "id": "chatcmpl-xxx",
-  "created": 1234567890,
-  "model": "Qwen/Qwen-Image",
-  "choices": [{
-    "index": 0,
-    "message": {
-      "role": "assistant",
-      "content": [{
-        "type": "image_url",
-        "image_url": {
-          "url": "data:image/png;base64,..."
-        }
-      }]
-    },
-    "finish_reason": "stop"
-  }],
-  "usage": {...}
-}
-```
-
-## Extract Image
-
-```bash
-# Extract base64 from response and decode to image
-cat response.json | jq -r '.choices[0].message.content[0].image_url.url' | cut -d',' -f2- | base64 -d > output.png
-```
-
-## File Description
-
-| File                        | Description                  |
-| --------------------------- | ---------------------------- |
-| `run_server.sh`             | Server startup script        |
-| `run_curl_text_to_image.sh` | curl example                 |
-| `openai_chat_client.py`     | Python client                |
-| `gradio_demo.py`            | Gradio interactive interface |
-
-## Example materials
-
-??? abstract "gradio_demo.py"
-    ``````py
-    --8<-- "examples/online_serving/text_to_image/gradio_demo.py"
-    ``````
-??? abstract "openai_chat_client.py"
-    ``````py
-    --8<-- "examples/online_serving/text_to_image/openai_chat_client.py"
-    ``````
-??? abstract "run_curl_text_to_image.sh"
-    ``````sh
-    --8<-- "examples/online_serving/text_to_image/run_curl_text_to_image.sh"
-    ``````
-??? abstract "run_server.sh"
-    ``````sh
-    --8<-- "examples/online_serving/text_to_image/run_server.sh"
-    ``````

docs/user_guide/teacache.md

@@ -4,15 +4,15 @@ TeaCache speeds up diffusion model inference by caching transformer computations
 
 ## Quick Start
 
-Enable TeaCache by setting `cache_backend` to `"tea_cache"`:
+Enable TeaCache by setting `cache_adapter` to `"tea_cache"`:
 
 ```python
 from vllm_omni import Omni
 
-# Simple configuration - model_type is automatically extracted from pipeline.__class__.__name__
+# Simple configuration - model_class_name and model_type are auto-detected
 omni = Omni(
     model="Qwen/Qwen-Image",
-    cache_backend="tea_cache",
+    cache_adapter="tea_cache",
     cache_config={
         "rel_l1_thresh": 0.2  # Optional, defaults to 0.2
     }
@@ -25,10 +25,10 @@ outputs = omni.generate(prompt="A cat sitting on a windowsill", num_inference_st
 You can also enable TeaCache via environment variable:
 
 ```bash
-export DIFFUSION_CACHE_BACKEND=tea_cache
+export DIFFUSION_CACHE_ADAPTER=tea_cache
 ```
 
-Then initialize without explicitly setting `cache_backend`:
+Then initialize without explicitly setting `cache_adapter`:
 
 ```python
 from vllm_omni import Omni
@@ -39,16 +39,6 @@ omni = Omni(
 )
 ```
 
-## Online Serving (OpenAI-Compatible)
-
-Enable TeaCache for online serving by passing `--cache-backend tea_cache` when starting the server:
-
-```bash
-vllm serve Qwen/Qwen-Image --omni --port 8091 \
-  --cache-backend tea_cache \
-  --cache-config '{"rel_l1_thresh": 0.2}'
-```
-
 ## Configuration Parameters
 
 ### `rel_l1_thresh` (float, default: `0.2`)
@@ -71,7 +61,7 @@ from vllm_omni import Omni
 
 omni = Omni(
     model="Qwen/Qwen-Image",
-    cache_backend="tea_cache",
+    cache_adapter="tea_cache",
     cache_config={"rel_l1_thresh": 0.2}
 )
 outputs = omni.generate(prompt="A cat sitting on a windowsill", num_inference_steps=50)
@@ -97,36 +87,13 @@ cache_config={"rel_l1_thresh": 0.1}  # More conservative caching
 
 ## Supported Models
 
-### ImageGen
+Currently supported models:
 
-<style>
-th {
-  white-space: nowrap;
-  min-width: 0 !important;
-}
-</style>
+- **QwenImagePipeline**
+  - Model identifier: `"Qwen/Qwen-Image"`
+  - Example: `model="Qwen/Qwen-Image"`
 
-| Architecture | Models | Example HF Models |
-|--------------|--------|-------------------|
-| `QwenImagePipeline` | Qwen-Image | `Qwen/Qwen-Image` |
-| `QwenImageEditPipeline` | Qwen-Image-Edit | `Qwen/Qwen-Image-Edit` |
-| `QwenImageEditPlusPipeline` | Qwen-Image-Edit-2509 | `Qwen/Qwen-Image-Edit-2509` |
-| `QwenImageLayeredPipeline` | Qwen-Image-Layered | `Qwen/Qwen-Image-Layered` |
+Future support (extractors in development):
 
-### VideoGen
-
-No VideoGen models are supported by TeaCache yet.
-
-### Coming Soon
-
-<style>
-th {
-  white-space: nowrap;
-  min-width: 0 !important;
-}
-</style>
-
-| Architecture | Models | Example HF Models |
-|--------------|--------|-------------------|
-| `FluxPipeline` | Flux | - |
-| `CogVideoXPipeline` | CogVideoX | - |
+- **FluxPipeline** - Coming soon
+- **CogVideoXPipeline** - Coming soon

examples/offline_inference/image_to_image/image_edit.py

@@ -4,65 +4,12 @@
 """
 Example script for image editing with Qwen-Image-Edit.
 
-Usage (single image):
+Usage:
     python image_edit.py \
         --image input.png \
         --prompt "Let this mascot dance under the moon, surrounded by floating stars and poetic bubbles such as 'Be Kind'" \
         --output output_image_edit.png \
         --num_inference_steps 50 \
-        --cfg_scale 4.0 \
-        --guidance_scale 1.0
-
-Usage (multiple images):
-    python image_edit.py \
-        --image input1.png input2.png input3.png \
-        --prompt "Combine these images into a single scene" \
-        --output output_image_edit.png \
-        --num_inference_steps 50 \
-        --cfg_scale 4.0 \
-        --guidance_scale 1.0
-
-Usage (with cache-dit acceleration):
-    python image_edit.py \
-        --image input.png \
-        --prompt "Edit description" \
-        --cache_backend cache_dit \
-        --cache_dit_max_continuous_cached_steps 3 \
-        --cache_dit_residual_diff_threshold 0.24 \
-        --cache_dit_enable_taylorseer
-
-Usage (with tea_cache acceleration):
-    python image_edit.py \
-        --image input.png \
-        --prompt "Edit description" \
-        --cache_backend tea_cache \
-        --tea_cache_rel_l1_thresh 0.25
-
-Usage (layered):
-    python image_edit.py \
-        --model "Qwen/Qwen-Image-Layered" \
-        --image input.png \
-        --prompt "" \
-        --output "layered" \
-        --num_inference_steps 50 \
-        --cfg_scale 4.0 \
-        --layers 4 \
-        --color-format "RGBA"
-
-Usage (with CFG Parallel):
-    python image_edit.py \
-        --image input.png \
-        --prompt "Edit description" \
-        --cfg_parallel_size 2 \
-        --num_inference_steps 50 \
-        --cfg_scale 4.0
-
-Usage (disable torch.compile):
-    python image_edit.py \
-        --image input.png \
-        --prompt "Edit description" \
-        --enforce_eager \
-        --num_inference_steps 50 \
         --cfg_scale 4.0
 
 For more options, run:
@@ -71,15 +18,12 @@ For more options, run:
 
 import argparse
 import os
-import time
 from pathlib import Path
 
 import torch
 from PIL import Image
 
-from vllm_omni.diffusion.data import DiffusionParallelConfig, logger
 from vllm_omni.entrypoints.omni import Omni
-from vllm_omni.outputs import OmniRequestOutput
 from vllm_omni.utils.platform_utils import detect_device_type, is_npu
 
 
@@ -88,18 +32,13 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument(
         "--model",
         default="Qwen/Qwen-Image-Edit",
-        help=(
-            "Diffusion model name or local path. "
-            "For multiple image inputs, use Qwen/Qwen-Image-Edit-2509 or Qwen/Qwen-Image-Edit-2511"
-            "which supports QwenImageEditPlusPipeline."
-        ),
+        help="Diffusion model name or local path.",
     )
     parser.add_argument(
         "--image",
         type=str,
-        nargs="+",
         required=True,
-        help="Path(s) to input image file(s) (PNG, JPG, etc.). Can specify multiple images.",
+        help="Path to input image file (PNG, JPG, etc.).",
     )
     parser.add_argument(
         "--prompt",
@@ -123,28 +62,13 @@ def parse_args() -> argparse.Namespace:
         "--cfg_scale",
         type=float,
         default=4.0,
-        help=(
-            "True classifier-free guidance scale (default: 4.0). Guidance scale as defined in Classifier-Free "
-            "Diffusion Guidance. Classifier-free guidance is enabled by setting cfg_scale > 1 and providing "
-            "a negative_prompt. Higher guidance scale encourages images closely linked to the text prompt, "
-            "usually at the expense of lower image quality."
-        ),
-    )
-    parser.add_argument(
-        "--guidance_scale",
-        type=float,
-        default=1.0,
-        help=(
-            "Guidance scale for guidance-distilled models (default: 1.0, disabled). "
-            "Unlike classifier-free guidance (--cfg_scale), guidance-distilled models take the guidance scale "
-            "directly as an input parameter. Enabled when guidance_scale > 1. Ignored when not using guidance-distilled models."
-        ),
+        help="True classifier-free guidance scale specific to Qwen-Image-Edit.",
     )
     parser.add_argument(
         "--output",
         type=str,
         default="output_image_edit.png",
-        help=("Path to save the edited image (PNG). Or prefix for Qwen-Image-Layered model save images(PNG)."),
+        help="Path to save the edited image (PNG).",
     )
     parser.add_argument(
         "--num_outputs_per_prompt",
@@ -158,141 +82,19 @@ def parse_args() -> argparse.Namespace:
         default=50,
         help="Number of denoising steps for the diffusion sampler.",
     )
-    parser.add_argument(
-        "--cache_backend",
-        type=str,
-        default=None,
-        choices=["cache_dit", "tea_cache"],
-        help=(
-            "Cache backend to use for acceleration. "
-            "Options: 'cache_dit' (DBCache + SCM + TaylorSeer), 'tea_cache' (Timestep Embedding Aware Cache). "
-            "Default: None (no cache acceleration)."
-        ),
-    )
-    parser.add_argument(
-        "--ulysses_degree",
-        type=int,
-        default=1,
-        help="Number of GPUs used for ulysses sequence parallelism.",
-    )
-    parser.add_argument(
-        "--ring_degree",
-        type=int,
-        default=1,
-        help="Number of GPUs used for ring sequence parallelism.",
-    )
-    parser.add_argument("--layers", type=int, default=4, help="Number of layers to decompose the input image into.")
-    parser.add_argument(
-        "--resolution",
-        type=int,
-        default=640,
-        help="Bucket in (640, 1024) to determine the condition and output resolution",
-    )
-
-    parser.add_argument(
-        "--color-format",
-        type=str,
-        default="RGB",
-        help="For Qwen-Image-Layered, set to RGBA.",
-    )
-
-    # Cache-DiT specific parameters
-    parser.add_argument(
-        "--cache_dit_fn_compute_blocks",
-        type=int,
-        default=1,
-        help="[cache-dit] Number of forward compute blocks. Optimized for single-transformer models.",
-    )
-    parser.add_argument(
-        "--cache_dit_bn_compute_blocks",
-        type=int,
-        default=0,
-        help="[cache-dit] Number of backward compute blocks.",
-    )
-    parser.add_argument(
-        "--cache_dit_max_warmup_steps",
-        type=int,
-        default=4,
-        help="[cache-dit] Maximum warmup steps (works for few-step models).",
-    )
-    parser.add_argument(
-        "--cache_dit_residual_diff_threshold",
-        type=float,
-        default=0.24,
-        help="[cache-dit] Residual diff threshold. Higher values enable more aggressive caching.",
-    )
-    parser.add_argument(
-        "--cache_dit_max_continuous_cached_steps",
-        type=int,
-        default=3,
-        help="[cache-dit] Maximum continuous cached steps to prevent precision degradation.",
-    )
-    parser.add_argument(
-        "--cache_dit_enable_taylorseer",
-        action="store_true",
-        default=False,
-        help="[cache-dit] Enable TaylorSeer acceleration (not suitable for few-step models).",
-    )
-    parser.add_argument(
-        "--cache_dit_taylorseer_order",
-        type=int,
-        default=1,
-        help="[cache-dit] TaylorSeer polynomial order.",
-    )
-    parser.add_argument(
-        "--cache_dit_scm_steps_mask_policy",
-        type=str,
-        default=None,
-        choices=[None, "slow", "medium", "fast", "ultra"],
-        help="[cache-dit] SCM mask policy: None (disabled), slow, medium, fast, ultra.",
-    )
-    parser.add_argument(
-        "--cache_dit_scm_steps_policy",
-        type=str,
-        default="dynamic",
-        choices=["dynamic", "static"],
-        help="[cache-dit] SCM steps policy: dynamic or static.",
-    )
-
-    # TeaCache specific parameters
-    parser.add_argument(
-        "--tea_cache_rel_l1_thresh",
-        type=float,
-        default=0.2,
-        help="[tea_cache] Threshold for accumulated relative L1 distance.",
-    )
-    parser.add_argument(
-        "--cfg_parallel_size",
-        type=int,
-        default=1,
-        choices=[1, 2],
-        help="Number of GPUs used for classifier free guidance parallel size.",
-    )
-    parser.add_argument(
-        "--enforce_eager",
-        action="store_true",
-        help="Disable torch.compile and force eager execution.",
-    )
     return parser.parse_args()
 
 
 def main():
     args = parse_args()
 
-    # Validate input images exist and load them
-    input_images = []
-    for image_path in args.image:
-        if not os.path.exists(image_path):
-            raise FileNotFoundError(f"Input image not found: {image_path}")
+    # Validate input image exists
+    if not os.path.exists(args.image):
+        raise FileNotFoundError(f"Input image not found: {args.image}")
 
-        img = Image.open(image_path).convert(args.color_format)
-        input_images.append(img)
-
-    # Use single image or list based on number of inputs
-    if len(input_images) == 1:
-        input_image = input_images[0]
-    else:
-        input_image = input_images
+    # Load input image
+    input_image = Image.open(args.image).convert("RGB")
+    print(f"Loaded input image from {args.image} (size: {input_image.size})")
 
     device = detect_device_type()
     generator = torch.Generator(device=device).manual_seed(args.seed)
@@ -300,100 +102,26 @@ def main():
     # Enable VAE memory optimizations on NPU
     vae_use_slicing = is_npu()
     vae_use_tiling = is_npu()
-    parallel_config = DiffusionParallelConfig(
-        ulysses_degree=args.ulysses_degree, ring_degree=args.ring_degree, cfg_parallel_size=args.cfg_parallel_size
-    )
 
-    # Configure cache based on backend type
-    cache_config = None
-    if args.cache_backend == "cache_dit":
-        # cache-dit configuration: Hybrid DBCache + SCM + TaylorSeer
-        cache_config = {
-            "Fn_compute_blocks": args.cache_dit_fn_compute_blocks,
-            "Bn_compute_blocks": args.cache_dit_bn_compute_blocks,
-            "max_warmup_steps": args.cache_dit_max_warmup_steps,
-            "residual_diff_threshold": args.cache_dit_residual_diff_threshold,
-            "max_continuous_cached_steps": args.cache_dit_max_continuous_cached_steps,
-            "enable_taylorseer": args.cache_dit_enable_taylorseer,
-            "taylorseer_order": args.cache_dit_taylorseer_order,
-            "scm_steps_mask_policy": args.cache_dit_scm_steps_mask_policy,
-            "scm_steps_policy": args.cache_dit_scm_steps_policy,
-        }
-    elif args.cache_backend == "tea_cache":
-        # TeaCache configuration
-        cache_config = {
-            "rel_l1_thresh": args.tea_cache_rel_l1_thresh,
-            # Note: coefficients will use model-specific defaults based on model_type
-        }
-
-    # Initialize Omni with appropriate pipeline
+    # Initialize Omni with QwenImageEditPipeline
     omni = Omni(
         model=args.model,
+        model_class_name="QwenImageEditPipeline",
         vae_use_slicing=vae_use_slicing,
         vae_use_tiling=vae_use_tiling,
-        cache_backend=args.cache_backend,
-        cache_config=cache_config,
-        parallel_config=parallel_config,
-        enforce_eager=args.enforce_eager,
     )
     print("Pipeline loaded")
 
-    # Time profiling for generation
-    print(f"\n{'=' * 60}")
-    print("Generation Configuration:")
-    print(f"  Model: {args.model}")
-    print(f"  Inference steps: {args.num_inference_steps}")
-    print(f"  Cache backend: {args.cache_backend if args.cache_backend else 'None (no acceleration)'}")
-    if isinstance(input_image, list):
-        print(f"  Number of input images: {len(input_image)}")
-        for idx, img in enumerate(input_image):
-            print(f"    Image {idx + 1} size: {img.size}")
-    else:
-        print(f"  Input image size: {input_image.size}")
-    print(
-        f"  Parallel configuration: ulysses_degree={args.ulysses_degree}, ring_degree={args.ring_degree}, cfg_parallel_size={args.cfg_parallel_size}"
-    )
-    print(f"{'=' * 60}\n")
-
-    generation_start = time.perf_counter()
     # Generate edited image
-    generate_kwargs = {
-        "prompt": args.prompt,
-        "pil_image": input_image,
-        "negative_prompt": args.negative_prompt,
-        "generator": generator,
-        "true_cfg_scale": args.cfg_scale,
-        "guidance_scale": args.guidance_scale,
-        "num_inference_steps": args.num_inference_steps,
-        "num_outputs_per_prompt": args.num_outputs_per_prompt,
-        "layers": args.layers,
-        "resolution": args.resolution,
-    }
-
-    outputs = omni.generate(**generate_kwargs)
-    generation_end = time.perf_counter()
-    generation_time = generation_end - generation_start
-
-    # Print profiling results
-    print(f"Total generation time: {generation_time:.4f} seconds ({generation_time * 1000:.2f} ms)")
-
-    if not outputs:
-        raise ValueError("No output generated from omni.generate()")
-    logger.info("Outputs: %s", outputs)
-
-    # Extract images from OmniRequestOutput
-    # omni.generate() returns list[OmniRequestOutput], extract images from request_output[0].images
-    first_output = outputs[0]
-    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[0]
-    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 not images:
-        raise ValueError("No images found in request_output")
+    images = omni.generate(
+        prompt=args.prompt,
+        pil_image=input_image,
+        negative_prompt=args.negative_prompt,
+        generator=generator,
+        true_cfg_scale=args.cfg_scale,
+        num_inference_steps=args.num_inference_steps,
+        num_outputs_per_prompt=args.num_outputs_per_prompt,
+    )
 
     # Save output image(s)
     output_path = Path(args.output)
@@ -401,30 +129,14 @@ def main():
     suffix = output_path.suffix or ".png"
     stem = output_path.stem or "output_image_edit"
 
-    # Handle layered output (each image may be a list of layers)
     if args.num_outputs_per_prompt <= 1:
-        img = images[0]
-        # Check if this is a layered output (list of images)
-        if isinstance(img, list):
-            for sub_idx, sub_img in enumerate(img):
-                save_path = output_path.parent / f"{stem}_{sub_idx}{suffix}"
-                sub_img.save(save_path)
-                print(f"Saved edited image to {os.path.abspath(save_path)}")
-        else:
-            img.save(output_path)
-            print(f"Saved edited image to {os.path.abspath(output_path)}")
+        images[0].save(output_path)
+        print(f"Saved edited image to {os.path.abspath(output_path)}")
     else:
         for idx, img in enumerate(images):
-            # Check if this is a layered output (list of images)
-            if isinstance(img, list):
-                for sub_idx, sub_img in enumerate(img):
-                    save_path = output_path.parent / f"{stem}_{idx}_{sub_idx}{suffix}"
-                    sub_img.save(save_path)
-                    print(f"Saved edited image to {os.path.abspath(save_path)}")
-            else:
-                save_path = output_path.parent / f"{stem}_{idx}{suffix}"
-                img.save(save_path)
-                print(f"Saved edited image to {os.path.abspath(save_path)}")
+            save_path = output_path.parent / f"{stem}_{idx}{suffix}"
+            img.save(save_path)
+            print(f"Saved edited image to {os.path.abspath(save_path)}")
 
 
 if __name__ == "__main__":

examples/offline_inference/image_to_image/image_to_image.md

@@ -1,49 +1,30 @@
-# Image-To-Image
+# Qwen-Image-Edit Offline Inference
+
+Source <https://github.com/vllm-project/vllm-omni/tree/main/examples/offline_inference/image_to_image>. Added in PR [#196](https://github.com/vllm-project/vllm-omni/pull/196).
 
 This example edits an input image with `Qwen/Qwen-Image-Edit` using the `image_edit.py` CLI.
 
 ## Local CLI Usage
 
-### Single Image Editing
-
-Download the example image:
-
-```bash
-wget https://vllm-public-assets.s3.us-west-2.amazonaws.com/omni-assets/qwen-bear.png
-```
-
-Then run:
-
 ```bash
 python image_edit.py \
-  --image qwen-bear.png \
+  --image qwen_bear.png \
   --prompt "Let this mascot dance under the moon, surrounded by floating stars and poetic bubbles such as 'Be Kind'" \
   --output output_image_edit.png \
   --num_inference_steps 50 \
   --cfg_scale 4.0
 ```
 
-### Multiple Image Editing (Qwen-Image-Edit-2509)
-
-For multiple image inputs, use `Qwen/Qwen-Image-Edit-2509` or  `Qwen/Qwen-Image-Edit-2511`:
-
-```bash
-python image_edit.py \
-  --model Qwen/Qwen-Image-Edit-2509 \
-  --image img1.png img2.png \
-  --prompt "Combine these images into a single scene" \
-  --output output_image_edit.png \
-  --num_inference_steps 50 \
-  --cfg_scale 4.0 \
-  --guidance_scale 1.0
-```
-
 Key arguments:
-
-- `--model`: model name or path. Use `Qwen/Qwen-Image-Edit-2509` or later for multiple image support.
-- `--image`: path(s) to the source image(s) (PNG/JPG, converted to RGB). Can specify multiple images.
+- `--image`: path to the source image (PNG/JPG, converted to RGB).
 - `--prompt` / `--negative_prompt`: text description (string).
-- `--cfg_scale`: true classifier-free guidance scale (default: 4.0). Classifier-free guidance is enabled by setting cfg_scale > 1 and providing a negative_prompt. Higher guidance scale encourages images closely linked to the text prompt, usually at the expense of lower image quality.
-- `--guidance_scale`: guidance scale for guidance-distilled models (default: 1.0, disabled). Unlike classifier-free guidance (--cfg_scale), guidance-distilled models take the guidance scale directly as an input parameter. Enabled when guidance_scale > 1. Ignored when not using guidance-distilled models.
+- `--cfg_scale`: true CFG scale for Qwen-Image-Edit (quality vs. fidelity).
 - `--num_inference_steps`: diffusion sampling steps (more steps = higher quality, slower).
 - `--output`: path to save the generated PNG.
+
+## Example materials
+
+??? abstract "image_edit.py"
+    ``````py
+    --8<-- "examples/offline_inference/image_to_image/image_edit.py"
+    ``````

examples/offline_inference/image_to_image/run_qwen_image_edit_2511.sh

@@ -1,8 +0,0 @@
-python image_edit.py \
-    --model Qwen/Qwen-Image-Edit-2511 \
-    --image qwen_bear.png \
-    --prompt "Add a white art board written with colorful text 'vLLM-Omni' on grassland. Add a paintbrush in the bear's hands. position the bear standing in front of the art board as if painting" \
-    --output output_image_edit.png \
-    --num_inference_steps 50 \
-    --cfg_scale 4.0 \
-    --cache_backend  cache_dit \

examples/offline_inference/image_to_video/README.md

@@ -1,56 +0,0 @@
-# Image-To-Video
-
-This example demonstrates how to generate videos from images using Wan2.2 Image-to-Video models with vLLM-Omni's offline inference API.
-
-## Local CLI Usage
-
-### Wan2.2-I2V-A14B-Diffusers (MoE)
-```bash
-python image_to_video.py \
-  --model Wan-AI/Wan2.2-I2V-A14B-Diffusers \
-  --image input.png \
-  --prompt "A cat playing with yarn, smooth motion" \
-  --negative_prompt "<optional quality filter>" \
-  --height 480 \
-  --width 832 \
-  --num_frames 48 \
-  --guidance_scale 5.0 \
-  --guidance_scale_high 6.0 \
-  --num_inference_steps 40 \
-  --boundary_ratio 0.875 \
-  --flow_shift 12.0 \
-  --fps 16 \
-  --output i2v_output.mp4
-```
-
-### Wan2.2-TI2V-5B-Diffusers (Unified)
-```bash
-python image_to_video.py \
-  --model Wan-AI/Wan2.2-TI2V-5B-Diffusers \
-  --image input.png \
-  --prompt "A cat playing with yarn, smooth motion" \
-  --negative_prompt "<optional quality filter>" \
-  --height 480 \
-  --width 832 \
-  --num_frames 48 \
-  --guidance_scale 4.0 \
-  --num_inference_steps 40 \
-  --flow_shift 12.0 \
-  --fps 16 \
-  --output i2v_output.mp4
-```
-
-Key arguments:
-
-- `--model`: Model ID (I2V-A14B for MoE, TI2V-5B for unified T2V+I2V).
-- `--image`: Path to input image (required).
-- `--prompt`: Text description of desired motion/animation.
-- `--height/--width`: Output resolution (auto-calculated from image if not set). Dimensions should be multiples of 16.
-- `--num_frames`: Number of frames (default 81).
-- `--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 (5.0 for 720p, 12.0 for 480p).
-- `--num_inference_steps`: Number of denoising steps (default 50).
-- `--fps`: Frames per second for the saved MP4 (requires `diffusers` export_to_video).
-- `--output`: Path to save the generated video.

examples/offline_inference/image_to_video/image_to_video.py

@@ -1,183 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-"""
-Image-to-Video generation example using Wan2.2 I2V/TI2V models.
-
-Supports:
-- Wan2.2-I2V-A14B-Diffusers: MoE model with CLIP image encoder
-- Wan2.2-TI2V-5B-Diffusers: Unified T2V+I2V model (dense 5B)
-
-Usage:
-    # I2V-A14B (MoE)
-    python image_to_video.py --model Wan-AI/Wan2.2-I2V-A14B-Diffusers \
-        --image input.jpg --prompt "A cat playing with yarn"
-
-    # TI2V-5B (unified)
-    python image_to_video.py --model Wan-AI/Wan2.2-TI2V-5B-Diffusers \
-        --image input.jpg --prompt "A cat playing with yarn"
-"""
-
-import argparse
-from pathlib import Path
-
-import numpy as np
-import PIL.Image
-import torch
-
-from vllm_omni.entrypoints.omni import Omni
-from vllm_omni.outputs import OmniRequestOutput
-from vllm_omni.utils.platform_utils import detect_device_type, is_npu
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Generate a video from an image with Wan2.2 I2V/TI2V.")
-    parser.add_argument(
-        "--model",
-        default="Wan-AI/Wan2.2-I2V-A14B-Diffusers",
-        help="Diffusers Wan2.2 I2V model ID or local path.",
-    )
-    parser.add_argument("--image", required=True, help="Path to input image.")
-    parser.add_argument("--prompt", default="", help="Text prompt describing the desired motion.")
-    parser.add_argument("--negative_prompt", default="", help="Negative prompt.")
-    parser.add_argument("--seed", type=int, default=42, help="Random seed.")
-    parser.add_argument("--guidance_scale", type=float, default=5.0, help="CFG scale.")
-    parser.add_argument(
-        "--guidance_scale_high", type=float, default=None, help="Optional separate CFG for high-noise (MoE only)."
-    )
-    parser.add_argument(
-        "--height", type=int, default=None, help="Video height (auto-calculated from image if not set)."
-    )
-    parser.add_argument("--width", type=int, default=None, help="Video width (auto-calculated from image if not set).")
-    parser.add_argument("--num_frames", type=int, default=81, help="Number of frames.")
-    parser.add_argument("--num_inference_steps", type=int, default=50, help="Sampling steps.")
-    parser.add_argument("--boundary_ratio", type=float, default=0.875, help="Boundary split ratio for MoE models.")
-    parser.add_argument(
-        "--flow_shift", type=float, default=5.0, help="Scheduler flow_shift (5.0 for 720p, 12.0 for 480p)."
-    )
-    parser.add_argument("--output", type=str, default="i2v_output.mp4", help="Path to save the video (mp4).")
-    parser.add_argument("--fps", type=int, default=16, help="Frames per second for the output video.")
-    return parser.parse_args()
-
-
-def calculate_dimensions(image: PIL.Image.Image, max_area: int = 480 * 832) -> tuple[int, int]:
-    """Calculate output dimensions maintaining aspect ratio."""
-    aspect_ratio = image.height / image.width
-    mod_value = 16  # Must be divisible by 16
-
-    height = round(np.sqrt(max_area * aspect_ratio)) // mod_value * mod_value
-    width = round(np.sqrt(max_area / aspect_ratio)) // mod_value * mod_value
-
-    return height, width
-
-
-def main():
-    args = parse_args()
-    device = detect_device_type()
-    generator = torch.Generator(device=device).manual_seed(args.seed)
-
-    # Load input image
-    image = PIL.Image.open(args.image).convert("RGB")
-
-    # Calculate dimensions if not provided
-    height = args.height
-    width = args.width
-    if height is None or width is None:
-        # Default to 480P area for I2V
-        calc_height, calc_width = calculate_dimensions(image, max_area=480 * 832)
-        height = height or calc_height
-        width = width or calc_width
-
-    # Resize image to target dimensions
-    image = image.resize((width, height), PIL.Image.Resampling.LANCZOS)
-
-    # Enable VAE memory optimizations on NPU
-    vae_use_slicing = is_npu()
-    vae_use_tiling = is_npu()
-
-    omni = Omni(
-        model=args.model,
-        vae_use_slicing=vae_use_slicing,
-        vae_use_tiling=vae_use_tiling,
-        boundary_ratio=args.boundary_ratio,
-        flow_shift=args.flow_shift,
-    )
-
-    # omni.generate() returns Generator[OmniRequestOutput, None, None]
-    frames = omni.generate(
-        args.prompt,
-        negative_prompt=args.negative_prompt,
-        pil_image=image,
-        height=height,
-        width=width,
-        generator=generator,
-        guidance_scale=args.guidance_scale,
-        guidance_scale_2=args.guidance_scale_high,
-        num_inference_steps=args.num_inference_steps,
-        num_frames=args.num_frames,
-    )
-
-    # Extract video frames from OmniRequestOutput
-    if isinstance(frames, list) and len(frames) > 0:
-        first_item = frames[0]
-
-        # Check if it's an OmniRequestOutput
-        if hasattr(first_item, "final_output_type"):
-            if first_item.final_output_type != "image":
-                raise ValueError(
-                    f"Unexpected output type '{first_item.final_output_type}', expected 'image' for video generation."
-                )
-
-            # Pipeline mode: extract from nested request_output
-            if hasattr(first_item, "is_pipeline_output") and first_item.is_pipeline_output:
-                if isinstance(first_item.request_output, list) and len(first_item.request_output) > 0:
-                    inner_output = first_item.request_output[0]
-                    if isinstance(inner_output, OmniRequestOutput) and hasattr(inner_output, "images"):
-                        frames = inner_output.images[0] if inner_output.images else None
-                        if frames is None:
-                            raise ValueError("No video frames found in output.")
-            # Diffusion mode: use direct images field
-            elif hasattr(first_item, "images") and first_item.images:
-                frames = first_item.images
-            else:
-                raise ValueError("No video frames found in OmniRequestOutput.")
-
-    output_path = Path(args.output)
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-
-    try:
-        from diffusers.utils import export_to_video
-    except ImportError:
-        raise ImportError("diffusers is required for export_to_video.")
-
-    # frames may be np.ndarray (preferred) or torch.Tensor
-    # export_to_video expects a list of frames with values in [0, 1]
-    if isinstance(frames, torch.Tensor):
-        video_tensor = frames.detach().cpu()
-        if video_tensor.dim() == 5:
-            # [B, C, F, H, W] or [B, F, H, W, C]
-            if video_tensor.shape[1] in (3, 4):
-                video_tensor = video_tensor[0].permute(1, 2, 3, 0)
-            else:
-                video_tensor = video_tensor[0]
-        elif video_tensor.dim() == 4 and video_tensor.shape[0] in (3, 4):
-            video_tensor = video_tensor.permute(1, 2, 3, 0)
-        # If float, assume [-1,1] and normalize to [0,1]
-        if video_tensor.is_floating_point():
-            video_tensor = video_tensor.clamp(-1, 1) * 0.5 + 0.5
-        video_array = video_tensor.float().numpy()
-    else:
-        video_array = frames
-        if hasattr(video_array, "shape") and video_array.ndim == 5:
-            video_array = video_array[0]
-
-    # Convert 4D array (frames, H, W, C) to list of frames for export_to_video
-    if isinstance(video_array, np.ndarray) and video_array.ndim == 4:
-        video_array = list(video_array)
-
-    export_to_video(video_array, str(output_path), fps=args.fps)
-    print(f"Saved generated video to {output_path}")
-
-
-if __name__ == "__main__":
-    main()

examples/offline_inference/qwen2_5_omni/README.md

@@ -1,16 +1,26 @@
-# Qwen2.5-Omni
+# Offline Example of vLLM-Omni for Qwen2.5-Omni
 
-## 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.
+## 🛠️ Installation
 
-## Run examples
+Please refer to [README.md](../../../README.md)
+
+## Run examples (Qwen2.5-Omni)
 
 ### Multiple Prompts
+Download dataset from [seed_tts](https://drive.google.com/file/d/1GlSjVfSHkW3-leKKBlfrjuuTGqQ_xaLP/edit). To get the prompt, you can:
+```bash
+tar -xf <Your Download Path>/seedtts_testset.tar
+cp seedtts_testset/en/meta.lst examples/offline_inference/qwen2_5_omni/meta.lst
+python3 examples/offline_inference/qwen2_5_omni/extract_prompts.py \
+  --input examples/offline_inference/qwen2_5_omni/meta.lst \
+  --output examples/offline_inference/qwen2_5_omni/top100.txt \
+  --topk 100
+```
 Get into the example folder
 ```bash
 cd examples/offline_inference/qwen2_5_omni
 ```
-Then run the command below. Note: for processing large volume data, it uses py_generator mode, which will return a python generator from Omni class.
+Then run the command below.
 ```bash
 bash run_multiple_prompts.sh
 ```
@@ -25,14 +35,6 @@ Then run the command below.
 bash run_single_prompt.sh
 ```
 
-### Modality control
-If you want to control output modalities, e.g. only output text, you can run the command below:
-```bash
-python end2end.py --output-wav output_audio \
-                  --query-type mixed_modalities \
-                  --modalities text
-```
-
 #### Using Local Media Files
 The `end2end.py` script supports local media files (audio, video, image) via CLI arguments:
 

examples/offline_inference/qwen2_5_omni/end2end.py

@@ -6,8 +6,7 @@ with the correct prompt format on Qwen2.5-Omni
 """
 
 import os
-import time
-from typing import NamedTuple
+from typing import NamedTuple, Optional
 
 import librosa
 import numpy as np
@@ -18,7 +17,7 @@ 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.sampling_params import SamplingParams
-from vllm.utils.argparse_utils import FlexibleArgumentParser
+from vllm.utils import FlexibleArgumentParser
 
 from vllm_omni.entrypoints.omni import Omni
 
@@ -59,9 +58,9 @@ def get_text_query(question: str = None) -> QueryResult:
 
 
 def get_mixed_modalities_query(
-    video_path: str | None = None,
-    image_path: str | None = None,
-    audio_path: str | None = None,
+    video_path: Optional[str] = None,
+    image_path: Optional[str] = None,
+    audio_path: Optional[str] = None,
     num_frames: int = 16,
     sampling_rate: int = 16000,
 ) -> QueryResult:
@@ -115,12 +114,12 @@ def get_mixed_modalities_query(
 
 
 def get_use_audio_in_video_query(
-    video_path: str | None = None, num_frames: int = 16, sampling_rate: int = 16000
+    video_path: Optional[str] = None, num_frames: int = 16, sampling_rate: int = 16000
 ) -> QueryResult:
     question = "Describe the content of the video, then convert what the baby say into text."
     prompt = (
         f"<|im_start|>system\n{default_system}<|im_end|>\n"
-        "<|im_start|>user\n<|vision_bos|><|VIDEO|><|vision_eos|><|audio_bos|><|AUDIO|><|audio_eos|>"
+        "<|im_start|>user\n<|vision_bos|><|VIDEO|><|vision_eos|>"
         f"{question}<|im_end|>\n"
         f"<|im_start|>assistant\n"
     )
@@ -152,7 +151,7 @@ def get_use_audio_in_video_query(
     )
 
 
-def get_multi_audios_query(audio_path: str | None = None, sampling_rate: int = 16000) -> QueryResult:
+def get_multi_audios_query(audio_path: Optional[str] = None, sampling_rate: int = 16000) -> QueryResult:
     question = "Are these two audio clips the same?"
     prompt = (
         f"<|im_start|>system\n{default_system}<|im_end|>\n"
@@ -191,7 +190,7 @@ def get_multi_audios_query(audio_path: str | None = None, sampling_rate: int = 1
     )
 
 
-def get_image_query(question: str = None, image_path: str | None = None) -> QueryResult:
+def get_image_query(question: str = None, image_path: Optional[str] = None) -> QueryResult:
     if question is None:
         question = "What is the content of this image?"
     prompt = (
@@ -220,7 +219,7 @@ def get_image_query(question: str = None, image_path: str | None = None) -> Quer
     )
 
 
-def get_video_query(question: str = None, video_path: str | None = None, num_frames: int = 16) -> QueryResult:
+def get_video_query(question: str = None, video_path: Optional[str] = None, num_frames: int = 16) -> QueryResult:
     if question is None:
         question = "Why is this video funny?"
     prompt = (
@@ -248,7 +247,7 @@ def get_video_query(question: str = None, video_path: str | None = None, num_fra
     )
 
 
-def get_audio_query(question: str = None, audio_path: str | None = None, sampling_rate: int = 16000) -> QueryResult:
+def get_audio_query(question: str = None, audio_path: Optional[str] = None, sampling_rate: int = 16000) -> QueryResult:
     if question is None:
         question = "What is the content of this audio?"
     prompt = (
@@ -320,10 +319,12 @@ def main(args):
         query_result = query_func(audio_path=audio_path, sampling_rate=sampling_rate)
     else:
         query_result = query_func()
+
     omni_llm = Omni(
         model=model_name,
         log_stats=args.enable_stats,
-        stage_init_timeout=args.stage_init_timeout,
+        log_file=("omni_llm_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,
@@ -372,30 +373,19 @@ def main(args):
             prompts = [get_text_query(ln).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 i, prompt in enumerate(prompts):
-            prompt["modalities"] = output_modalities
-
-    profiler_enabled = bool(os.getenv("VLLM_TORCH_PROFILER_DIR"))
-    if profiler_enabled:
-        omni_llm.start_profile(stages=[0])
-    omni_generator = omni_llm.generate(prompts, sampling_params_list, py_generator=args.py_generator)
+    omni_outputs = omni_llm.generate(prompts, sampling_params_list)
 
     # Determine output directory: prefer --output-dir; fallback to --output-wav
     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
-    for stage_outputs in omni_generator:
+    for stage_outputs in omni_outputs:
         if stage_outputs.final_output_type == "text":
             for output in stage_outputs.request_output:
-                request_id = output.request_id
+                request_id = int(output.request_id)
                 text_output = output.outputs[0].text
                 # Save aligned text file per request
-                prompt_text = output.prompt
-                out_txt = os.path.join(output_dir, f"{request_id}.txt")
+                prompt_text = prompts[request_id]["prompt"]
+                out_txt = os.path.join(output_dir, f"{request_id:05d}.txt")
                 lines = []
                 lines.append("Prompt:\n")
                 lines.append(str(prompt_text) + "\n")
@@ -409,24 +399,12 @@ def main(args):
                 print(f"Request ID: {request_id}, Text saved to {out_txt}")
         elif stage_outputs.final_output_type == "audio":
             for output in stage_outputs.request_output:
-                request_id = output.request_id
+                request_id = int(output.request_id)
                 audio_tensor = output.multimodal_output["audio"]
-                output_wav = os.path.join(output_dir, f"output_{request_id}.wav")
+                output_wav = os.path.join(output_dir, f"output_{output.request_id}.wav")
                 sf.write(output_wav, audio_tensor.detach().cpu().numpy(), samplerate=24000)
                 print(f"Request ID: {request_id}, Saved audio to {output_wav}")
 
-        processed_count += len(stage_outputs.request_output)
-        if profiler_enabled and processed_count >= total_requests:
-            print(f"[Info] Processed {processed_count}/{total_requests}. Stopping profiler inside active loop...")
-            # Stop the profiler while workers are still alive
-            omni_llm.stop_profile()
-
-            print("[Info] Waiting 30s for workers to write massive trace files to disk...")
-            time.sleep(30)
-            print("[Info] Trace export wait finished.")
-
-    omni_llm.close()
-
 
 def parse_args():
     parser = FlexibleArgumentParser(description="Demo on using vLLM for offline inference with audio language models")
@@ -445,10 +423,10 @@ def parse_args():
         help="Enable writing detailed statistics (default: disabled)",
     )
     parser.add_argument(
-        "--stage-init-timeout",
+        "--init-sleep-seconds",
         type=int,
-        default=300,
-        help="Timeout for initializing a single stage in seconds (default: 300)",
+        default=20,
+        help="Sleep seconds after starting each stage process to allow initialization (default: 20)",
     )
     parser.add_argument(
         "--batch-timeout",
@@ -527,18 +505,6 @@ def parse_args():
         default=None,
         help="Address of the Ray cluster.",
     )
-    parser.add_argument(
-        "--modalities",
-        type=str,
-        default=None,
-        help="Modalities to use for the prompts.",
-    )
-    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.",
-    )
     return parser.parse_args()
 
 

examples/offline_inference/qwen2_5_omni/extract_prompts.py

@@ -1,8 +1,9 @@
 #!/usr/bin/env python3
 import argparse
+from typing import Optional
 
 
-def extract_prompt(line: str) -> str | None:
+def extract_prompt(line: str) -> Optional[str]:
     # Extract the content between the first '|' and the second '|'
     i = line.find("|")
     if i == -1:

examples/offline_inference/qwen2_5_omni/run_multiple_prompts.sh

@@ -1,4 +1,3 @@
 python end2end.py --output-wav output_audio \
                   --query-type text \
-                  --txt-prompts ../qwen3_omni/text_prompts_10.txt \
-                  --py-generator
+                  --txt-prompts top10.txt

examples/offline_inference/qwen3_omni/README.md

@@ -1,16 +1,18 @@
-# Qwen3-Omni
+# Offline Example of vLLM-Omni for Qwen3-Omni
 
-## 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.
+## 🛠️ Installation
 
-## Run examples
+Please refer to [README.md](../../../README.md)
+
+## Run examples (Qwen3-Omni)
 
 ### Multiple Prompts
+Download dataset from [seed_tts](https://drive.google.com/file/d/1GlSjVfSHkW3-leKKBlfrjuuTGqQ_xaLP/edit). For processing dataset please refer to [Qwen2.5-Omni README.md](../qwen2_5_omni/README.md)
 Get into the example folder
 ```bash
 cd examples/offline_inference/qwen3_omni
 ```
-Then run the command below. Note: for processing large volume data, it uses py_generator mode, which will return a python generator from Omni class.
+Then run the command below.
 ```bash
 bash run_multiple_prompts.sh
 ```
@@ -28,14 +30,6 @@ If you have not enough memory, you can set thinker with tensor parallel. Just ru
 bash run_single_prompt_tp.sh
 ```
 
-### Modality control
-If you want to control output modalities, e.g. only output text, you can run the command below:
-```bash
-python end2end.py --output-wav output_audio \
-                  --query-type use_audio \
-                  --modalities text
-```
-
 #### Using Local Media Files
 The `end2end.py` script supports local media files (audio, video, image) via command-line arguments:
 
@@ -48,12 +42,6 @@ python end2end.py --query-type use_image --image-path /path/to/image.jpg
 
 # Use local audio file
 python end2end.py --query-type use_audio --audio-path /path/to/audio.wav
-
-# Combine multiple local media files
-python end2end.py --query-type mixed_modalities \
-    --video-path /path/to/video.mp4 \
-    --image-path /path/to/image.jpg \
-    --audio-path /path/to/audio.wav
 ```
 
 If media file paths are not provided, the script will use default assets. Supported query types:
@@ -61,8 +49,6 @@ If media file paths are not provided, the script will use default assets. Suppor
 - `use_image`: Image input
 - `use_audio`: Audio input
 - `text`: Text-only query
-- `multi_audios`: Multiple audio inputs
-- `mixed_modalities`: Combination of video, image, and audio inputs
 
 ### FAQ
 

examples/offline_inference/qwen3_omni/end2end.py

@@ -6,8 +6,7 @@ with the correct prompt format on Qwen3-Omni (thinker only).
 """
 
 import os
-import time
-from typing import NamedTuple
+from typing import NamedTuple, Optional
 
 import librosa
 import numpy as np
@@ -18,7 +17,7 @@ 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.utils.argparse_utils import FlexibleArgumentParser
+from vllm.utils import FlexibleArgumentParser
 
 from vllm_omni.entrypoints.omni import Omni
 
@@ -58,7 +57,7 @@ def get_text_query(question: str = None) -> QueryResult:
     )
 
 
-def get_video_query(question: str = None, video_path: str | None = None, num_frames: int = 16) -> QueryResult:
+def get_video_query(question: str = None, video_path: Optional[str] = None, num_frames: int = 16) -> QueryResult:
     if question is None:
         question = "Why is this video funny?"
     prompt = (
@@ -86,7 +85,7 @@ def get_video_query(question: str = None, video_path: str | None = None, num_fra
     )
 
 
-def get_image_query(question: str = None, image_path: str | None = None) -> QueryResult:
+def get_image_query(question: str = None, image_path: Optional[str] = None) -> QueryResult:
     if question is None:
         question = "What is the content of this image?"
     prompt = (
@@ -115,7 +114,7 @@ def get_image_query(question: str = None, image_path: str | None = None) -> Quer
     )
 
 
-def get_audio_query(question: str = None, audio_path: str | None = None, sampling_rate: int = 16000) -> QueryResult:
+def get_audio_query(question: str = None, audio_path: Optional[str] = None, sampling_rate: int = 16000) -> QueryResult:
     if question is None:
         question = "What is the content of this audio?"
     prompt = (
@@ -144,94 +143,11 @@ def get_audio_query(question: str = None, audio_path: str | None = None, samplin
     )
 
 
-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,
-) -> QueryResult:
-    question = "What is recited in the audio? What is the content of this image? Why is this video funny?"
-    prompt = (
-        f"<|im_start|>system\n{default_system}<|im_end|>\n"
-        "<|im_start|>user\n<|audio_start|><|audio_pad|><|audio_end|>"
-        "<|vision_start|><|image_pad|><|vision_end|>"
-        "<|vision_start|><|video_pad|><|vision_end|>"
-        f"{question}<|im_end|>\n"
-        f"<|im_start|>assistant\n"
-    )
-
-    # Load video
-    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
-
-    # Load image
-    if image_path:
-        if not os.path.exists(image_path):
-            raise FileNotFoundError(f"Image file not found: {image_path}")
-        pil_image = Image.open(image_path)
-        image_data = convert_image_mode(pil_image, "RGB")
-    else:
-        image_data = convert_image_mode(ImageAsset("cherry_blossom").pil_image, "RGB")
-
-    # Load audio
-    if audio_path:
-        if not os.path.exists(audio_path):
-            raise FileNotFoundError(f"Audio file not found: {audio_path}")
-        audio_signal, sr = librosa.load(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": prompt,
-            "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() -> QueryResult:
-    question = "Are these two audio clips the same?"
-    prompt = (
-        f"<|im_start|>system\n{default_system}<|im_end|>\n"
-        "<|im_start|>user\n<|audio_start|><|audio_pad|><|audio_end|>"
-        "<|audio_start|><|audio_pad|><|audio_end|>"
-        f"{question}<|im_end|>\n"
-        f"<|im_start|>assistant\n"
-    )
-    return QueryResult(
-        inputs={
-            "prompt": prompt,
-            "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,
-    "multi_audios": get_multi_audios_query,
-    "mixed_modalities": get_mixed_modalities_query,
 }
 
 
@@ -251,22 +167,12 @@ def main(args):
         query_result = query_func(image_path=image_path)
     elif args.query_type == "use_audio":
         query_result = query_func(audio_path=audio_path, sampling_rate=getattr(args, "sampling_rate", 16000))
-    elif args.query_type == "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),
-        )
     else:
         query_result = query_func()
 
     omni_llm = Omni(
         model=model_name,
         stage_configs_path=args.stage_configs_path,
-        log_stats=args.enable_stats,
-        stage_init_timeout=args.stage_init_timeout,
     )
 
     thinker_sampling_params = SamplingParams(
@@ -315,30 +221,19 @@ def main(args):
             prompts = [get_text_query(ln).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 i, prompt in enumerate(prompts):
-            prompt["modalities"] = output_modalities
-
-    profiler_enabled = bool(os.getenv("VLLM_TORCH_PROFILER_DIR"))
-    if profiler_enabled:
-        omni_llm.start_profile(stages=[0])
-    omni_generator = omni_llm.generate(prompts, sampling_params_list, py_generator=args.py_generator)
+    omni_outputs = omni_llm.generate(prompts, sampling_params_list)
     # Determine output directory: prefer --output-dir; fallback to --output-wav
     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
-
-    for stage_outputs in omni_generator:
+    for stage_outputs in omni_outputs:
         if stage_outputs.final_output_type == "text":
             for output in stage_outputs.request_output:
-                request_id = output.request_id
+                request_id = int(output.request_id)
                 text_output = output.outputs[0].text
                 # Save aligned text file per request
-                prompt_text = output.prompt
-                out_txt = os.path.join(output_dir, f"{request_id}.txt")
+                prompt_text = prompts[request_id]["prompt"]
+                out_txt = os.path.join(output_dir, f"{request_id:05d}.txt")
                 lines = []
                 lines.append("Prompt:\n")
                 lines.append(str(prompt_text) + "\n")
@@ -352,9 +247,9 @@ def main(args):
                 print(f"Request ID: {request_id}, Text saved to {out_txt}")
         elif stage_outputs.final_output_type == "audio":
             for output in stage_outputs.request_output:
-                request_id = output.request_id
+                request_id = int(output.request_id)
                 audio_tensor = output.multimodal_output["audio"]
-                output_wav = os.path.join(output_dir, f"output_{request_id}.wav")
+                output_wav = os.path.join(output_dir, f"output_{output.request_id}.wav")
 
                 # Convert to numpy array and ensure correct format
                 audio_numpy = audio_tensor.float().detach().cpu().numpy()
@@ -367,17 +262,6 @@ def main(args):
                 sf.write(output_wav, audio_numpy, samplerate=24000, format="WAV")
                 print(f"Request ID: {request_id}, Saved audio to {output_wav}")
 
-        processed_count += len(stage_outputs.request_output)
-        if profiler_enabled and processed_count >= total_requests:
-            print(f"[Info] Processed {processed_count}/{total_requests}. Stopping profiler inside active loop...")
-            # Stop the profiler while workers are still alive
-            omni_llm.stop_profile()
-
-            print("[Info] Waiting 30s for workers to write trace files to disk...")
-            time.sleep(30)
-            print("[Info] Trace export wait time finished.")
-    omni_llm.close()
-
 
 def parse_args():
     parser = FlexibleArgumentParser(description="Demo on using vLLM for offline inference with audio language models")
@@ -396,10 +280,10 @@ def parse_args():
         help="Enable writing detailed statistics (default: disabled)",
     )
     parser.add_argument(
-        "--stage-init-timeout",
+        "--init-sleep-seconds",
         type=int,
-        default=300,
-        help="Timeout for initializing a single stage in seconds (default: 300)",
+        default=20,
+        help="Sleep seconds after starting each stage process to allow initialization (default: 20)",
     )
     parser.add_argument(
         "--batch-timeout",
@@ -475,24 +359,6 @@ def parse_args():
         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 to use for the prompts.",
-    )
-    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.",
-    )
 
     return parser.parse_args()
 

examples/offline_inference/qwen3_omni/run_multiple_prompts.sh

@@ -1,4 +1,3 @@
 python end2end.py --output-wav output_audio \
                   --query-type text \
-                  --txt-prompts text_prompts_10.txt \
-                  --py-generator
+                  --txt-prompts top10.txt

examples/offline_inference/qwen3_omni/run_single_prompt_tp.sh

@@ -1,5 +1,5 @@
 python end2end.py --output-wav output_audio \
                   --query-type use_audio \
-                  --stage-init-timeout 300
+                  --init-sleep-seconds 90
 
-# stage-init-timeout sets the maximum wait to avoid two vLLM stages initializing at the same time on the same card.
+# init-sleep-seconds works to avoid two vLLM stages initialized at the same time within a card.

examples/offline_inference/qwen3_omni/text_prompts_10.txt

@@ -1,10 +0,0 @@
-What is the capital of France?
-How many planets are in our solar system?
-What is the largest ocean on Earth?
-Who wrote the novel "1984"?
-What is the chemical symbol for water?
-What year did World War II end?
-What is the tallest mountain in the world?
-What is the speed of light in vacuum?
-Who painted the Mona Lisa?
-What is the smallest prime number?

examples/offline_inference/text_to_audio/text_to_audio.py

@@ -1,200 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
-
-"""
-Example script for text-to-audio generation using Stable Audio Open.
-
-This script demonstrates how to generate audio from text prompts using
-the Stable Audio Open model with vLLM-Omni.
-
-Usage:
-    python text_to_audio.py --prompt "The sound of a dog barking"
-    python text_to_audio.py --prompt "A piano playing a gentle melody" --audio_length 10.0
-    python text_to_audio.py --prompt "Thunder and rain sounds" --negative_prompt "Low quality"
-"""
-
-import argparse
-import time
-from pathlib import Path
-
-import numpy as np
-import torch
-
-from vllm_omni.entrypoints.omni import Omni
-from vllm_omni.utils.platform_utils import detect_device_type
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Generate audio with Stable Audio Open.")
-    parser.add_argument(
-        "--model",
-        default="stabilityai/stable-audio-open-1.0",
-        help="Stable Audio model name or local path.",
-    )
-    parser.add_argument(
-        "--prompt",
-        default="The sound of a hammer hitting a wooden surface.",
-        help="Text prompt for audio generation.",
-    )
-    parser.add_argument(
-        "--negative_prompt",
-        default="Low quality.",
-        help="Negative prompt for classifier-free guidance.",
-    )
-    parser.add_argument(
-        "--seed",
-        type=int,
-        default=42,
-        help="Random seed for deterministic results.",
-    )
-    parser.add_argument(
-        "--guidance_scale",
-        type=float,
-        default=7.0,
-        help="Classifier-free guidance scale.",
-    )
-    parser.add_argument(
-        "--audio_start",
-        type=float,
-        default=0.0,
-        help="Audio start time in seconds.",
-    )
-    parser.add_argument(
-        "--audio_length",
-        type=float,
-        default=10.0,
-        help="Audio length in seconds (max ~47s for stable-audio-open-1.0).",
-    )
-    parser.add_argument(
-        "--num_inference_steps",
-        type=int,
-        default=100,
-        help="Number of denoising steps for the diffusion sampler.",
-    )
-    parser.add_argument(
-        "--num_waveforms",
-        type=int,
-        default=1,
-        help="Number of audio waveforms to generate for the given prompt.",
-    )
-    parser.add_argument(
-        "--output",
-        type=str,
-        default="stable_audio_output.wav",
-        help="Path to save the generated audio (WAV format).",
-    )
-    parser.add_argument(
-        "--sample_rate",
-        type=int,
-        default=44100,
-        help="Sample rate for output audio (Stable Audio uses 44100 Hz).",
-    )
-    return parser.parse_args()
-
-
-def save_audio(audio_data: np.ndarray, output_path: str, sample_rate: int = 44100):
-    """Save audio data to a WAV file."""
-    try:
-        import soundfile as sf
-
-        sf.write(output_path, audio_data, sample_rate)
-    except ImportError:
-        try:
-            import scipy.io.wavfile as wav
-
-            # Ensure audio is in the correct format for scipy
-            if audio_data.dtype == np.float32 or audio_data.dtype == np.float64:
-                # Normalize to int16 range
-                audio_data = np.clip(audio_data, -1.0, 1.0)
-                audio_data = (audio_data * 32767).astype(np.int16)
-            wav.write(output_path, sample_rate, audio_data)
-        except ImportError:
-            raise ImportError(
-                "Either 'soundfile' or 'scipy' is required to save audio files. "
-                "Install with: pip install soundfile or pip install scipy"
-            )
-
-
-def main():
-    args = parse_args()
-    device = detect_device_type()
-    generator = torch.Generator(device=device).manual_seed(args.seed)
-
-    print(f"\n{'=' * 60}")
-    print("Stable Audio Open - Text-to-Audio Generation")
-    print(f"{'=' * 60}")
-    print(f"  Model: {args.model}")
-    print(f"  Prompt: {args.prompt}")
-    print(f"  Negative prompt: {args.negative_prompt}")
-    print(f"  Audio length: {args.audio_length}s")
-    print(f"  Inference steps: {args.num_inference_steps}")
-    print(f"  Guidance scale: {args.guidance_scale}")
-    print(f"  Seed: {args.seed}")
-    print(f"{'=' * 60}\n")
-
-    # Initialize Omni with Stable Audio model
-    omni = Omni(model=args.model)
-
-    # Calculate audio end time
-    audio_end_in_s = args.audio_start + args.audio_length
-
-    # Time profiling for generation
-    generation_start = time.perf_counter()
-
-    # Generate audio
-    audio = omni.generate(
-        args.prompt,
-        negative_prompt=args.negative_prompt,
-        generator=generator,
-        guidance_scale=args.guidance_scale,
-        num_inference_steps=args.num_inference_steps,
-        num_outputs_per_prompt=args.num_waveforms,
-        extra={
-            "audio_start_in_s": args.audio_start,
-            "audio_end_in_s": audio_end_in_s,
-        },
-    )
-
-    generation_end = time.perf_counter()
-    generation_time = generation_end - generation_start
-
-    print(f"Total generation time: {generation_time:.2f} seconds")
-
-    # Process and save audio
-    output_path = Path(args.output)
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    suffix = output_path.suffix or ".wav"
-    stem = output_path.stem or "stable_audio_output"
-
-    # Handle different output formats
-    if isinstance(audio, torch.Tensor):
-        audio = audio.cpu().float().numpy()
-
-    # Audio shape is typically [batch, channels, samples] or [channels, samples]
-    if audio.ndim == 3:
-        # [batch, channels, samples]
-        if args.num_waveforms <= 1:
-            audio_data = audio[0].T  # [samples, channels]
-            save_audio(audio_data, str(output_path), args.sample_rate)
-            print(f"Saved generated audio to {output_path}")
-        else:
-            for idx in range(audio.shape[0]):
-                audio_data = audio[idx].T  # [samples, channels]
-                save_path = output_path.parent / f"{stem}_{idx}{suffix}"
-                save_audio(audio_data, str(save_path), args.sample_rate)
-                print(f"Saved generated audio to {save_path}")
-    elif audio.ndim == 2:
-        # [channels, samples]
-        audio_data = audio.T  # [samples, channels]
-        save_audio(audio_data, str(output_path), args.sample_rate)
-        print(f"Saved generated audio to {output_path}")
-    else:
-        # [samples] - mono audio
-        save_audio(audio, str(output_path), args.sample_rate)
-        print(f"Saved generated audio to {output_path}")
-
-    print(f"\nGenerated {args.audio_length}s of audio at {args.sample_rate} Hz")
-
-
-if __name__ == "__main__":
-    main()