[Core] Align vLLM-Omni with vLLM 0.33.0

.buildkite/amd/scripts/aiter_mha_cache.py

@@ -105,6 +105,7 @@
     "pyproject.toml",
     "setup.py",
     "tools/install_torchcodec_rocm.sh",
+    "tools/build_gradio_pillow13.py",
 )
 _READ_SIZE = 1024 * 1024
 _MAX_HTTP_BYTES = 2 * 1024 * 1024
@@ -389,7 +390,11 @@ def dependency_identity(root: Path) -> str:
     if not requirement_dir.is_dir():
         return ""
     requirement_files = sorted(path for path in requirement_dir.glob("*.txt") if path.is_file())
+    backport_files = sorted((root / "tools/gradio_pillow13").glob("*"))
+    if not backport_files:
+        return ""
     files = [root / relative for relative in _IMAGE_DEPENDENCY_PATHS]
+    files.extend(backport_files)
     files.extend(requirement_files)
     if any(not path.is_file() for path in files):
         return ""

.buildkite/amd/scripts/build-ci-image.sh

@@ -25,6 +25,8 @@ dependency_files=(
     pyproject.toml
     setup.py
     tools/install_torchcodec_rocm.sh
+    tools/build_gradio_pillow13.py
+    tools/gradio_pillow13/*
 )
 while IFS= read -r dependency_file; do
     dependency_files+=("$dependency_file")

.buildkite/amd/test-amd-ready.yml

@@ -1223,7 +1223,7 @@ steps:
           marker="core_model and omni and rocm and MI325 and cards_1"
           pytest --collect-only -q "$${nodes[@]}" \
             --shard-id=0 --num-shards=1 \
-            -m "$$marker" --run-level core_model \
+            -m "$$marker" --run-level advanced_model \
             > "$$ROCM_MINICPMO_DUPLEX_ARTIFACT_DIR/collection.txt"
           count=$$(awk '/::/ { n++ } END { print n + 0 }' \
             "$$ROCM_MINICPMO_DUPLEX_ARTIFACT_DIR/collection.txt")
@@ -1247,7 +1247,7 @@ steps:
           timeout --signal=TERM --kill-after=1m 35m \
             pytest -s -v "$${nodes[@]}" \
             --shard-id=0 --num-shards=1 \
-            -m "core_model and omni and rocm and MI325 and cards_1" --run-level core_model \
+            -m "core_model and omni and rocm and MI325 and cards_1" --run-level advanced_model \
             --junitxml="$$ROCM_MINICPMO_DUPLEX_ARTIFACT_DIR/pytest.xml" || status=$$?
           if [[ "$$status" -eq 0 ]]; then
             if python -c 'import sys, xml.etree.ElementTree as ET; root = ET.parse(sys.argv[1]).getroot(); suites = [root] if root.tag == "testsuite" else list(root.findall("testsuite")); tests = sum(int(suite.attrib.get("tests", "0")) for suite in suites); skipped = sum(int(suite.attrib.get("skipped", "0")) for suite in suites); ok = tests == 2 and skipped == 0; print(f"Expected exactly two executed MiniCPM-o duplex tests; reported tests={tests}, skipped={skipped}.", file=sys.stderr) if not ok else None; raise SystemExit(0 if ok else 5)' "$$ROCM_MINICPMO_DUPLEX_ARTIFACT_DIR/pytest.xml"

.buildkite/cuda/scripts/build-ci-image.sh

@@ -1,4 +1,6 @@
 #!/bin/bash
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
 set -euo pipefail
 
 # Build and push the CI Docker image with registry-based layer caching.
@@ -28,8 +30,9 @@ aws ecr-public get-login-password --region "$REGION" \
 # This is because dependencies don't change often, so most PRs will have the same hash.
 #
 # The Dockerfile is also included to avoid churn in the cached image based on the vLLM version.
-DEP_FILES="pyproject.toml setup.py requirements/*.txt docker/Dockerfile.ci"
-CACHE_KEY=$(cat ${DEP_FILES} | sha256sum | cut -c1-16)
+DEP_FILES=(pyproject.toml setup.py requirements/*.txt docker/Dockerfile.ci
+    tools/build_gradio_pillow13.py tools/prepare_ci_telemetry.py tools/gradio_pillow13/*)
+CACHE_KEY=$(cat "${DEP_FILES[@]}" | sha256sum | cut -c1-16)
 CACHE_TAG="deps-cache-${CACHE_KEY}"
 echo "Cache key: ${CACHE_TAG}"
 

.buildkite/cuda/scripts/check_vllm_runtime.py

@@ -10,15 +10,31 @@
 
 
 def main() -> None:
-    dockerfile = Path(__file__).resolve().parents[3] / "docker" / "Dockerfile.ci"
+    root = Path(__file__).resolve().parents[3]
+    dockerfile = root / "docker" / "Dockerfile.ci"
+    text = dockerfile.read_text()
     match = re.search(
         r"^ARG VLLM_PRECOMPILED_WHEEL_COMMIT=([0-9a-f]{40})$",
-        dockerfile.read_text(),
+        text,
         re.MULTILINE,
     )
     if match is None:
         raise RuntimeError(f"Missing vLLM commit pin in {dockerfile}")
     expected_commit = match.group(1)
+    version_match = re.search(r"^ARG VLLM_VERSION=(\S+)$", text, re.MULTILINE)
+    if version_match is None:
+        raise RuntimeError(f"Missing vLLM version pin in {dockerfile}")
+    expected_version = version_match.group(1)
+    cudnn_requirements = root / "requirements/cudnn-runtime.txt"
+    cudnn_match = re.search(
+        r"^nvidia-cudnn-cu13==(\d+)\.(\d+)\.(\d+)\.\d+(?:\s|$)",
+        cudnn_requirements.read_text(),
+        re.MULTILINE,
+    )
+    if cudnn_match is None:
+        raise RuntimeError(f"Missing cuDNN runtime pin in {cudnn_requirements}")
+    major, minor, patch = map(int, cudnn_match.groups())
+    expected_cudnn = major * 10000 + minor * 100 + patch
 
     import torch
     import vllm
@@ -31,13 +47,20 @@ def main() -> None:
     assert len(installed_commit) >= 8 and expected_commit.startswith(installed_commit), (
         f"Expected vLLM {expected_commit}, got {__commit_id__} ({vllm.__version__})"
     )
+    # A final wheel can share its source SHA with an RC while containing
+    # different native binaries. Both identities must match this CI cycle.
+    assert vllm.__version__ == expected_version, f"Expected vLLM version {expected_version}, got {vllm.__version__}"
     assert torch.cuda.is_available(), "vLLM runtime check requires a GPU worker"
-    for module in ("flashinfer", "vllm._C_stable_libtorch"):
+    actual_cudnn = torch.backends.cudnn.version()
+    assert actual_cudnn == expected_cudnn, f"Expected cuDNN {expected_cudnn}, got {actual_cudnn}"
+    # Python dependency metadata cannot detect a retained connector wheel's
+    # Torch ABI mismatch. Import it on the GPU worker before running models.
+    for module in ("flashinfer", "vllm._C_stable_libtorch", "lmcache.cuda_ops"):
         importlib.import_module(module)
     print(
         f"Verified vLLM CUDA runtime: vllm={vllm.__version__} "
         f"commit={expected_commit} torch={torch.__version__} "
-        f"cuda={torch.version.cuda} device={torch.cuda.get_device_name()}"
+        f"cuda={torch.version.cuda} cudnn={actual_cudnn} device={torch.cuda.get_device_name()}"
     )
 
 

.buildkite/cuda/test-ready.yml

@@ -204,12 +204,13 @@ steps:
             "
         mirror_hardwares: h100_1
 
+      # The live client waits for a learned turn terminator; use real weights.
       - label: "Omni · MiniCPM-o 4.5 Duplex Test"
         source_file_dependencies: omni_minicpmo_4_5_duplex_function
         commands:
           - |
             timeout 35m bash -c "
-              pytest -s -v tests/e2e/online_serving/test_minicpmo_4_5_duplex.py tests/e2e/online_serving/test_duplex_client_live.py -m 'core_model and cuda' --run-level 'core_model'
+              pytest -s -v tests/e2e/online_serving/test_minicpmo_4_5_duplex.py tests/e2e/online_serving/test_duplex_client_live.py -m 'core_model and cuda' --run-level 'advanced_model'
             "
         mirror_hardwares: h100_1
 

.buildkite/intel/pipeline-intel.yml

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

docker/Dockerfile.ci

@@ -1,17 +1,23 @@
-# Align the CUDA base and commit-index wheel with the final v0.32.0 release.
-# Pin the published multi-platform image digest so CI uses the same release
-# stack even if the upstream tag is updated.
-ARG VLLM_PRECOMPILED_WHEEL_COMMIT=5df63a7203cdb9328d824a27b682e77c7b9928be
-ARG VLLM_VERSION=0.32.0
+# Install the final v0.33.0 package from its frozen commit index.
+# Use the matching published v0.33.0 image and verify the selected runtime
+# from its exact frozen wheel below.
+ARG VLLM_PRECOMPILED_WHEEL_COMMIT=4ba787ec9959e566d3b587a796dff07673324da5
+ARG VLLM_VERSION=0.33.0
 ARG VLLM_BASE_IMAGE=vllm/vllm-openai
-ARG VLLM_BASE_TAG=v${VLLM_VERSION}@sha256:befccf0e7e4089aa23926bb6f887a85c0d46c2a99e6de5c5ffdf5cb7957c5b34
+# Update the digest together with VLLM_VERSION; the digest selects the image bytes.
+ARG VLLM_BASE_TAG=v${VLLM_VERSION}@sha256:d825baf9ce4b1b6bfc5ecc7b79880c7e6748c65a72d697ce3d47607aafa84c6e
 
 # We use registry-based layer caching for the dependencies,
 # where the tag is determined based on the hash of the contents
 # of files like pyproject.toml, etc. The deps stage should have
 # everything except the actual project dir, since that should not
 # change much across branches.
 FROM ${VLLM_BASE_IMAGE}:${VLLM_BASE_TAG} AS deps
+ARG VLLM_BASE_IMAGE
+ARG VLLM_BASE_TAG
+# The base overrides Torch's NCCL dependency for its optional EFA build.
+# Resolve the official wheel's declared dependencies for the Omni runtime.
+ENV UV_OVERRIDE=""
 ARG VLLM_PRECOMPILED_WHEEL_COMMIT
 ARG VLLM_VERSION
 # Keep APP_DIR outside /workspace so k8s Buildkite workspace mounts cannot
@@ -38,19 +44,83 @@ RUN apt-get update && \
 # for CI
 COPY pyproject.toml setup.py ./
 COPY requirements/ requirements/
+COPY tools/build_gradio_pillow13.py tools/build_gradio_pillow13.py
+COPY tools/prepare_ci_telemetry.py tools/prepare_ci_telemetry.py
+COPY tools/gradio_pillow13/ tools/gradio_pillow13/
 # Scope the override to Omni; dependency source builds need their own versions.
 ENV VLLM_OMNI_VERSION_OVERRIDE=0.0.0
 # Editable install: deps + project metadata are cached in this layer, while
 # the package itself is linked to APP_DIR (populated later by COPY --link).
 # Do NOT use a non-editable install here — that copies an empty stub into
 # site-packages and breaks ``import vllm_omni.entrypoints``.
-RUN uv pip install --system \
+RUN python3 tools/build_gradio_pillow13.py --output-dir /tmp/gradio-pillow13
+# This exact base contains an unused exporter requiring a newer SDK than
+# LMCache supports. Validate its known metadata before removing that orphan.
+RUN python3 tools/prepare_ci_telemetry.py "${VLLM_BASE_IMAGE}:${VLLM_BASE_TAG}" && \
+    uv pip uninstall --system opentelemetry-exporter-otlp-common
+RUN uv pip install --system -r requirements/cuda-bootstrap.txt \
+    "nvidia-nccl-cu13==2.30.7" \
+    /tmp/gradio-pillow13/gradio-6.31.0+omni.pillow13-py3-none-any.whl \
     "vllm @ https://wheels.vllm.ai/${VLLM_PRECOMPILED_WHEEL_COMMIT}/vllm-${VLLM_VERSION}-cp38-abi3-manylinux_2_28_$(uname -m).whl" \
     -e ".[dev]"
+# The final base's LMCache wheel was compiled against Torch 2.13. Its CUDA
+# extension references a c10 symbol removed in Torch 2.14. Follow LMCache's
+# source workflow so the unchanged release is compiled against this runtime.
+RUN uv pip install --system -r requirements/cuda-bootstrap.txt \
+    ninja "packaging>=24.2" "setuptools>=77.0.3,<81.0.0" \
+    "setuptools_scm>=8" "grpcio==1.78.0" "grpcio-tools==1.78.0" wheel
+# CUDA builder images can lack the math-library headers supplied by the
+# installed NVIDIA packages. Keep all published LMCache CUDA architectures.
+# Disable the installer cache so an older Torch-specific source wheel cannot
+# satisfy this rebuild merely because its Python package version is unchanged.
+RUN PYTHON_SITE=$(python3 -c 'import sysconfig; print(sysconfig.get_path("purelib"))') && \
+    test -f "${PYTHON_SITE}/nvidia/cu13/include/cusparse.h" && \
+    test -f "${PYTHON_SITE}/nvidia/cusparselt/include/cusparseLt.h" && \
+    CUDA_VISIBLE_DEVICES="" CUDA_HOME=/usr/local/cuda BUILD_WITH_CUDA=1 MAX_JOBS=3 NVCC_THREADS=1 \
+    TORCH_CUDA_ARCH_LIST="7.5;8.0;8.6;8.9;9.0;10.0;11.0;12.0" \
+    CPATH="${PYTHON_SITE}/nvidia/cu13/include:${PYTHON_SITE}/nvidia/cusparselt/include${CPATH:+:${CPATH}}" \
+    uv pip install --system --no-cache --no-binary lmcache \
+    --no-build-isolation-package lmcache --reinstall-package lmcache \
+    -r requirements/cuda-bootstrap.txt "lmcache==0.5.6"
+RUN uv pip check --system && rm -rf /tmp/gradio-pillow13
+# cuDNN 9.24 causes the original Qwen-Image 2.1 pixel gate to fail under
+# Torch 2.14. Keep Torch's declared Python dependencies and load the verified
+# NVIDIA 9.25.1 wheel in a private target outside Python's import path.
+RUN uv pip install --target /opt/vllm-omni-cudnn --no-deps --only-binary=:all: \
+    --require-hashes -r requirements/cudnn-runtime.txt
+ENV LD_PRELOAD="/opt/vllm-omni-cudnn/nvidia/cudnn/lib/libcudnn.so.9 ${LD_PRELOAD:-}"
+ENV LD_LIBRARY_PATH="/opt/vllm-omni-cudnn/nvidia/cudnn/lib:${LD_LIBRARY_PATH:-/usr/local/nvidia/lib:/usr/local/nvidia/lib64}"
+
 # Fail the image build if dependency resolution replaced the selected vLLM.
 # The CPU builder has no NVIDIA driver; CUDA imports are checked at the start
 # of each GPU test job by .buildkite/cuda/scripts/check_vllm_runtime.py.
-RUN python3 -c "from vllm._version import __commit_id__; commit = (__commit_id__ or '').removeprefix('g'); assert len(commit) >= 8 and '${VLLM_PRECOMPILED_WHEEL_COMMIT}'.startswith(commit), __commit_id__"
+RUN python3 -c "from vllm._version import __commit_id__, __version__; commit = (__commit_id__ or '').removeprefix('g'); assert len(commit) >= 8 and '${VLLM_PRECOMPILED_WHEEL_COMMIT}'.startswith(commit), __commit_id__; assert __version__ == '${VLLM_VERSION}', __version__"
+
+# Exercise ordinary tools and Torch CPU operations with the preload enabled.
+# Record driver/device visibility so a CPU-builder result has an explicit scope.
+RUN uv pip check --system && python3 - <<'PY'
+import glob
+import json
+import os
+from pathlib import Path
+
+import torch
+
+maps = Path("/proc/self/maps").read_text()
+assert any(os.path.realpath(path) in maps for path in os.environ["LD_PRELOAD"].split() if "libcudnn.so.9" in path)
+assert torch.arange(4, device="cpu").sum().item() == 6
+cuda_available = torch.cuda.is_available()
+assert not torch.cuda.is_initialized()
+print(json.dumps({
+    "cpu_preload_smoke": "passed",
+    "cudnn": torch.backends.cudnn.version(),
+    "cuda_available": cuda_available,
+    "cuda_initialized": torch.cuda.is_initialized(),
+    "gpu_device_nodes": sorted(glob.glob("/dev/nvidia*")),
+    "driver_module_visible": Path("/sys/module/nvidia").exists(),
+    "driver_proc_visible": Path("/proc/driver/nvidia/version").exists(),
+}))
+PY
 
 # The final stage just copies the working dir on top of the
 # dependencies image. This uses --link so that we can skip

docker/Dockerfile.cuda

@@ -1,6 +1,14 @@
-ARG BASE_IMAGE=vllm/vllm-openai:v0.32.0
+ARG BASE_IMAGE=vllm/vllm-openai:v0.33.0@sha256:d825baf9ce4b1b6bfc5ecc7b79880c7e6748c65a72d697ce3d47607aafa84c6e
 FROM ${BASE_IMAGE}
+ARG BASE_IMAGE
+# The base's optional EFA NCCL override conflicts with Torch 2.14 metadata.
+# Use the official wheel's declared NCCL dependency for the Omni runtime.
+ENV UV_OVERRIDE=""
 
+# Verify the final runtime using the same frozen wheel as CUDA CI, on the
+# matching published base image. Omni runtime qualification is pending.
+ARG VLLM_PRECOMPILED_WHEEL_COMMIT=4ba787ec9959e566d3b587a796dff07673324da5
+ARG VLLM_VERSION=0.33.0
 ARG COMMON_WORKDIR=/app
 
 WORKDIR ${COMMON_WORKDIR}
@@ -15,7 +23,42 @@ RUN mkdir -p ${COMMON_WORKDIR}/vllm-omni
 
 # Step 2: Copy vllm-omni code and install
 COPY . ${COMMON_WORKDIR}/vllm-omni
-RUN cd ${COMMON_WORKDIR}/vllm-omni && uv pip install --python "$(python3 -c 'import sys; print(sys.executable)')" --no-cache-dir "."
+# Apply the same guarded bootstrap repair and dependency pins as CUDA CI.
+RUN python3 vllm-omni/tools/prepare_ci_telemetry.py "${BASE_IMAGE}" && \
+    uv pip uninstall --python "$(python3 -c 'import sys; print(sys.executable)')" opentelemetry-exporter-otlp-common
+RUN cd ${COMMON_WORKDIR}/vllm-omni && uv pip install --python "$(python3 -c 'import sys; print(sys.executable)')" --no-cache-dir \
+    -r requirements/cuda-bootstrap.txt \
+    "nvidia-nccl-cu13==2.30.7" \
+    "vllm @ https://wheels.vllm.ai/${VLLM_PRECOMPILED_WHEEL_COMMIT}/vllm-${VLLM_VERSION}-cp38-abi3-manylinux_2_28_$(uname -m).whl" \
+    "."
+
+# The published final base still ships an LMCache wheel with the Torch 2.13
+# CUDA ABI. Rebuild the same release against Torch 2.14, retaining every
+# published CUDA architecture.
+RUN uv pip install --python "$(python3 -c 'import sys; print(sys.executable)')" \
+    -r ${COMMON_WORKDIR}/vllm-omni/requirements/cuda-bootstrap.txt \
+    ninja "packaging>=24.2" "setuptools>=77.0.3,<81.0.0" \
+    "setuptools_scm>=8" "grpcio==1.78.0" "grpcio-tools==1.78.0" wheel
+RUN PYTHON_SITE=$(python3 -c 'import sysconfig; print(sysconfig.get_path("purelib"))') && \
+    test -f "${PYTHON_SITE}/nvidia/cu13/include/cusparse.h" && \
+    test -f "${PYTHON_SITE}/nvidia/cusparselt/include/cusparseLt.h" && \
+    CUDA_VISIBLE_DEVICES="" CUDA_HOME=/usr/local/cuda BUILD_WITH_CUDA=1 MAX_JOBS=3 NVCC_THREADS=1 \
+    TORCH_CUDA_ARCH_LIST="7.5;8.0;8.6;8.9;9.0;10.0;11.0;12.0" \
+    CPATH="${PYTHON_SITE}/nvidia/cu13/include:${PYTHON_SITE}/nvidia/cusparselt/include${CPATH:+:${CPATH}}" \
+    uv pip install --python "$(python3 -c 'import sys; print(sys.executable)')" \
+    --no-cache --no-binary lmcache --no-build-isolation-package lmcache --reinstall-package lmcache \
+    -r ${COMMON_WORKDIR}/vllm-omni/requirements/cuda-bootstrap.txt "lmcache==0.5.6"
+RUN uv pip check --python "$(python3 -c 'import sys; print(sys.executable)')"
+
+# cuDNN 9.24 causes the original Qwen-Image 2.1 pixel gate to fail under
+# Torch 2.14. Keep Torch's declared Python dependencies and load the verified
+# NVIDIA 9.25.1 wheel in a private target outside Python's import path.
+RUN uv pip install --target /opt/vllm-omni-cudnn --no-deps --only-binary=:all: \
+    --require-hashes -r ${COMMON_WORKDIR}/vllm-omni/requirements/cudnn-runtime.txt
+ENV LD_PRELOAD="/opt/vllm-omni-cudnn/nvidia/cudnn/lib/libcudnn.so.9 ${LD_PRELOAD:-}"
+ENV LD_LIBRARY_PATH="/opt/vllm-omni-cudnn/nvidia/cudnn/lib:${LD_LIBRARY_PATH:-/usr/local/nvidia/lib:/usr/local/nvidia/lib64}"
+
+RUN python3 -c "from vllm._version import __commit_id__, __version__; commit = (__commit_id__ or '').removeprefix('g'); assert len(commit) >= 8 and '${VLLM_PRECOMPILED_WHEEL_COMMIT}'.startswith(commit), __commit_id__; assert __version__ == '${VLLM_VERSION}', __version__"
 
 RUN ln -sf /usr/bin/python3 /usr/bin/python
 

docker/Dockerfile.npu

@@ -1,3 +1,7 @@
+# Legacy Ascend 0.32 runtime; this default does not qualify the vLLM 0.33
+# alignment checkout. A matching 0.33 vLLM-Ascend image and NPU validation
+# are required before using this checkout. Override VLLM_ASCEND_IMAGE and
+# VLLM_ASCEND_VERSION only with that verified runtime; do not relabel 0.32.
 ARG VLLM_ASCEND_IMAGE=quay.io/atlas-ci/vllm-ascend
 ARG VLLM_ASCEND_VERSION=v0.32.0
 ARG VLLM_ASCEND_DEVICE_SUFFIX=

docker/Dockerfile.npu.ci

@@ -1,3 +1,7 @@
+# Legacy Ascend 0.32 runtime; this default does not qualify the vLLM 0.33
+# alignment checkout. A matching 0.33 vLLM-Ascend image and NPU validation
+# are required before using this checkout. Override VLLM_ASCEND_IMAGE and
+# VLLM_ASCEND_VERSION only with that verified runtime; do not relabel 0.32.
 ARG VLLM_ASCEND_IMAGE=quay.io/atlas-ci/vllm-ascend
 ARG VLLM_ASCEND_VERSION=v0.32.0
 ARG VLLM_ASCEND_DEVICE_SUFFIX=