Publish qualified portable vLLM 0.32.0 CUDA 13 runtime

releases/vllm-0.32.0-cu130-20261028-r1/README.md

@@ -0,0 +1,71 @@
+# Portable vLLM 0.32.0 / CUDA 13.0
+
+This GOLD-style release installs into `/opt/vllm-runtime-0.32.0-cu130`.
+It includes standalone Python 3.12.12, its independent venv, vLLM 0.32.0,
+Torch 2.13.0, the complete resolved `uv.lock`, a private CUDA 13.0 toolkit
+(excluding static archives/developer GUI tools), support libraries, helpers
+and tiny random-weight qualification fixtures. Other research runtimes are
+not modified. Production models, datasets, credentials and JIT caches stay
+outside the archive. Each dependency retains its own license.
+
+## Requirements
+
+Linux x86_64, glibc >= 2.35, an NVIDIA driver compatible with the selected GPU
+and CUDA 13.0, bash, GNU tar/gzip, `ldconfig`, and sufficient disk. JIT requires
+a working host C/C++ compiler and system development headers; GCC 11 is the
+build/restore baseline. The bundled toolkit supplies nvcc, CUDA headers and
+ptxas independently of `/usr/local/cuda`. NVIDIA kernel drivers and host glibc
+are never bundled/replaced. The GOLD-style fixed paths require root to install.
+This release is not an arbitrarily relocatable virtualenv.
+
+## Download and install
+
+Use the immutable HF payload revision and archive SHA256 in the release card.
+`download_release.py` is a Python 3.10+ stdlib downloader with bounded parallel
+HTTP ranges, strict range checks and complete file hashes. Use the existing
+company-approved proxy environment. It needs no HF token for this public repo.
+
+Download to a new directory; verify `SHA256SUMS`, then run `python3 install.py`.
+The installer verifies all files and the archive allowlist, refuses existing
+runtime paths, checks disk and glibc, installs only this release's private
+directory, then executes CPU/import checks with GPUs hidden. It never starts a
+server, modifies drivers/toolkits, or downloads packages.
+
+## Use
+
+`node/vllm.sh` accepts normal vLLM CLI arguments, including `serve /path/to/model`.
+`node/python-vllm.sh` accepts normal Python arguments/scripts.
+Both wrappers default to `CUDA_VISIBLE_DEVICES=-1`; explicitly expose only your
+assigned GPU(s). Model paths/revisions, serving options and output directories
+are supplied by the caller. HF/Transformers default to offline operation;
+stage production weights separately through the approved company transport.
+Override `VLLM_PORTABLE_CACHE` and `VLLM_PORTABLE_HF_HOME` for persistent caches.
+
+Calling the wrapper selects the runtime for that process. Stopping the server
+and its owned workers releases their GPU allocations. Shell activation or
+deactivation alone does not stop running processes. The serving wrapper is a
+foreground command; use your existing process manager for durable service.
+
+Run `node_gate.py` with the actual confirmed node label and assigned GPU UUID
+for a read-only occupancy check. `--run` additionally executes the shipped
+CPU, CUDA/CLI, normal compiled inference and local HTTP canaries. No helper kills
+other users' processes or infers GPU assignment from an idle device.
+
+## Qualification and provenance
+
+The release is gated on actual synthetic BF16 native CUDA operations, normal
+compiled dense Llama inference and loopback HTTP generation on a Modal B200.
+Its archive must also restore on a separate pinned Ubuntu 22.04 image without
+a system CUDA toolkit and with Internet blocked, followed by the same GPU inference/HTTP gates.
+The synthetic fixtures are random weights, not benchmark models or production
+assets. Qualification does not establish company-node compatibility, model
+quality, multi-GPU/NCCL, multimodal, quantization or every optional backend.
+
+`pins.json`, `uv.lock`, `build-facts.json`, `manifest.json`, qualification JSON,
+restore receipts and full remote logs identify exactly what was tested.
+Failures use new attempt IDs and remain in the evidence volume.
+
+Source lives in `experiments/vllm_runtime/`; this reuses the reviewed GOLD
+archive contract and downloader range implementation. Builds/package transfers
+run only on Modal. Personal-machine checks use existing Python/WSL stdlib,
+with no local ML dependency/model download or Docker daemon.

releases/vllm-0.32.0-cu130-20261028-r1/SHA256SUMS

@@ -0,0 +1,14 @@
+5e72ff86ba2dcda82ff75cb8788351703baec3191923f632f833cd5cbf005dd7  CUDA-LICENSES.txt
+3ff20c283001e54bb2f20ff9ce12ea5344b7b5ae2624ea51630acc4bb5f153a0  README.md
+694914d21aadcfe8c891bc92c8fe1072bf69ff6dc21c0c2ae00a1703231e0ad2  archive_contract.py
+887a82b972a29b8bb99118eb2616233cb2024adadddc4083e7d1197f990de72c  build-facts.json
+f98613a7a4f8883f2f8a3234dac0973bc00002deb3d5ff6e319e31ad19d20f3d  download_release.py
+e37c16fe6bdd925efae3f16974b49c9b6df169d9b011333b99a9f842f50304eb  install.py
+1c15d3434f4b41a4414b29633c1a6be6ca45c422a716b1ce416c13672a3af8d2  manifest.json
+c43da09e054b7967e75a68137fa4619b925dde5988bcbba14f64da898e1a3ea0  node_gate.py
+d56689414e3fa222ccf4a4c872b94430ab5dd02ff0b8e9cf37e62d4774dd3d6e  pins.json
+1771ab395f426c977f1c3052d75bf35ce95015159f72a669d5ee9833dd67eee4  python-vllm.sh
+66f5fb0c01ddbee0d6d5913e69aa04e85ee4cd1438b87d4972b1b42f527396ba  qualification.json
+b22e2ef9b1d1f1f2f233b9360bc82e8cb53b69c3d4811e3043167f0037db532b  runtime.tar.gz
+213282f08d00ba473c6692aa62b39de4c07c7029f7279db62c87850c3d1e6cd9  uv.lock
+2e93d80f0b6bab7d9d66436c18257526a72a05a6da8f537aeadad7e6b27d0b9e  vllm.sh

releases/vllm-0.32.0-cu130-20261028-r1/archive_contract.py

@@ -0,0 +1,34 @@
+"""Archive checks shared by export and install; no third-party dependencies."""
+import posixpath
+from pathlib import PurePosixPath
+import tarfile
+
+def inside(name,roots):
+    return any(name==root or name.startswith(root+'/') for root in roots)
+
+def review_archive(path,targets):
+    roots=[str(PurePosixPath(t)).lstrip('/') for t in targets]
+    if not roots or any(not t.startswith('/opt/') for t in targets):
+        raise ValueError('Only explicit /opt targets are permitted')
+    seen=set(); total=0; count=0
+    with tarfile.open(path,'r:gz') as archive:
+        for member in archive:
+            name=member.name
+            if name.startswith('/') or '..' in PurePosixPath(name).parts or not inside(name,roots):
+                raise ValueError('Member escapes runtime allowlist: '+name)
+            if name in seen: raise ValueError('Duplicate archive member: '+name)
+            seen.add(name); count+=1
+            if not (member.isfile() or member.isdir() or member.issym() or member.islnk()):
+                raise ValueError('Unsupported archive member type: '+name)
+            if member.issym():
+                link=member.linkname
+                target=posixpath.normpath(link.lstrip('/')) if link.startswith('/') else posixpath.normpath(posixpath.join(posixpath.dirname(name),link))
+                if not inside(target,roots): raise ValueError('Symlink escapes runtime allowlist: '+name)
+            if member.islnk():
+                if member.linkname.startswith('/') or not inside(posixpath.normpath(member.linkname),roots):
+                    raise ValueError('Hardlink escapes runtime allowlist: '+name)
+            if member.isfile(): total+=member.size
+    for root in roots:
+        if not any(name==root or name.startswith(root+'/') for name in seen):
+            raise ValueError('Missing runtime target: '+root)
+    return {'members':count,'unpacked_regular_file_bytes':total,'targets':targets}

releases/vllm-0.32.0-cu130-20261028-r1/build-facts.json

@@ -0,0 +1,22 @@
+{
+  "base_image": "docker.io/nvidia/cuda:13.0.2-devel-ubuntu22.04@sha256:1c517d4fb96528c8999e14e6e6b16d7e2ff9ae8d194fd788d60fdc88e693e982",
+  "python": "3.12.12",
+  "uv": "0.12.7",
+  "build_glibc": "glibc 2.35",
+  "nvcc": "nvcc: NVIDIA (R) Cuda compiler driver\nCopyright (c) 2005-2025 NVIDIA Corporation\nBuilt on Wed_Aug_20_01:58:59_PM_PDT_2025\nCuda compilation tools, release 13.0, V13.0.88\nBuild cuda_13.0.r13.0/compiler.36424714_0\n",
+  "gcc": "gcc (Ubuntu 11.4.0-1ubuntu1~22.04.2) 11.4.0",
+  "support_libraries": [
+    "libaio.so.1",
+    "libffi.so.8",
+    "libgcc_s.so.1",
+    "libgomp.so.1",
+    "libibverbs.so.1",
+    "libnl-3.so.200",
+    "libnl-route-3.so.200",
+    "libnuma.so.1",
+    "librdmacm.so.1",
+    "libstdc++.so.6",
+    "libuuid.so.1"
+  ],
+  "lock_sha256": "213282f08d00ba473c6692aa62b39de4c07c7029f7279db62c87850c3d1e6cd9"
+}

releases/vllm-0.32.0-cu130-20261028-r1/download_release.py

@@ -0,0 +1,100 @@
+"""Pinned public HF release download; no installation or GPU use."""
+import argparse
+import concurrent.futures
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import time
+import urllib.request
+
+REPO = 'codemaivanngu/vllm-portable-runtime'
+RUN = 'vllm-0.32.0-cu130-20261028-r1'
+
+
+def sha(path):
+    h = hashlib.sha256()
+    with Path(path).open('rb') as stream:
+        for chunk in iter(lambda: stream.read(8 * 1024**2), b''): h.update(chunk)
+    return h.hexdigest()
+
+
+def small(url, limit):
+    with urllib.request.urlopen(url, timeout=120) as response: data = response.read(limit + 1)
+    if len(data) > limit: raise RuntimeError('Unexpected metadata/file size')
+    return data
+
+
+def download_ranges(url, path, size, workers):
+    if not hasattr(os, 'pwrite'): raise RuntimeError('Parallel download requires Linux/Unix os.pwrite')
+    partial = path.with_name(path.name + '.partial')
+    fd = os.open(partial, os.O_RDWR | os.O_CREAT | os.O_EXCL, 0o600)
+    try:
+        os.ftruncate(fd, size)
+        chunk = 16 * 1024**2
+        def transfer(start):
+            end = min(start + chunk, size) - 1
+            for attempt in range(4):
+                try:
+                    request = urllib.request.Request(url, headers={'Range': f'bytes={start}-{end}'})
+                    with urllib.request.urlopen(request, timeout=180) as response:
+                        if response.status != 206 or response.headers.get('Content-Range', '') != f'bytes {start}-{end}/{size}':
+                            raise RuntimeError('Server did not honor the requested byte range')
+                        data = response.read(end - start + 2)
+                    if len(data) != end - start + 1: raise RuntimeError('Incomplete range')
+                    position = 0
+                    while position < len(data):
+                        count = os.pwrite(fd, data[position:], start + position)
+                        if count <= 0: raise RuntimeError('Range write failed')
+                        position += count
+                    return
+                except Exception:
+                    if attempt == 3: raise RuntimeError('Range transfer failed; inspect approved proxy/connectivity') from None
+                    time.sleep(2**attempt)
+        with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as pool:
+            for _ in pool.map(transfer, range(0, size, chunk)): pass
+        os.fsync(fd)
+    finally: os.close(fd)
+    return partial
+
+
+def download(revision, archive_sha256, output, workers):
+    if not re.fullmatch('[0-9a-f]{40}', revision): raise ValueError('Use the immutable 40-character payload revision')
+    if not re.fullmatch('[0-9a-f]{64}', archive_sha256): raise ValueError('Use the archive SHA256 from the release receipt')
+    if not 1 <= workers <= 16: raise ValueError('Use 1..16 workers')
+    base = f'https://huggingface.co/datasets/{REPO}/resolve/{revision}/releases/{RUN}'
+    output = Path(output); output.mkdir(parents=True, exist_ok=False)
+    raw = small(base + '/manifest.json', 1024**2); manifest = json.loads(raw)
+    if manifest['files']['runtime.tar.gz']['sha256'] != archive_sha256:
+        raise RuntimeError('Manifest does not identify the requested runtime')
+    (output / 'manifest.json').write_bytes(raw)
+    for name, item in manifest['files'].items():
+        if Path(name).name != name or name in ('', '.', '..'): raise RuntimeError('Unsafe manifest filename')
+        target = output / name
+        if name == 'runtime.tar.gz':
+            print('Downloading runtime with bounded parallel HTTP ranges...', flush=True)
+            partial = download_ranges(base + '/' + name, target, item['bytes'], workers)
+        else:
+            if item['bytes'] > 4 * 1024**2: raise RuntimeError('Unexpected non-archive size')
+            partial = target.with_name(target.name + '.partial')
+            partial.write_bytes(small(base + '/' + name, item['bytes']))
+        if partial.stat().st_size != item['bytes'] or sha(partial) != item['sha256']:
+            raise RuntimeError('File SHA256/size mismatch: ' + name)
+        partial.rename(target)
+    for name in ('SHA256SUMS', 'restore-cpu-receipt.json', 'restore-gpu-receipt.json'):
+        (output / name).write_bytes(small(base + '/' + name, 65536))
+    result = {'repo_id': REPO, 'payload_revision': revision, 'archive_sha256': archive_sha256,
+              'all_manifest_files_verified': True, 'gpu_used': False}
+    (output / 'download-receipt.json').write_text(json.dumps(result, indent=2))
+    print('VLLM_DOWNLOAD_RESULT=' + json.dumps(result), flush=True)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--revision', required=True)
+    parser.add_argument('--archive-sha256', required=True)
+    parser.add_argument('--output', required=True)
+    parser.add_argument('--workers', type=int, default=8)
+    args = parser.parse_args()
+    download(args.revision, args.archive_sha256, args.output, args.workers)

releases/vllm-0.32.0-cu130-20261028-r1/install.py

@@ -0,0 +1,53 @@
+"""Verified path-preserving installation. No package downloads or GPU use."""
+import json
+import os
+from pathlib import Path
+import platform
+import shutil
+import subprocess
+import sys
+from archive_contract import review_archive
+
+
+def sha(path):
+    import hashlib
+    h = hashlib.sha256()
+    with Path(path).open('rb') as stream:
+        for block in iter(lambda: stream.read(8 * 1024**2), b''): h.update(block)
+    return h.hexdigest()
+
+
+def install(payload):
+    payload = Path(payload).resolve()
+    manifest = json.loads((payload / 'manifest.json').read_text())
+    pins = manifest['pins']; root = Path(pins['root'])
+    if platform.system() != 'Linux' or platform.machine() != 'x86_64':
+        raise RuntimeError('Requires Linux x86_64')
+    libc = platform.libc_ver()
+    if libc[0] != 'glibc' or tuple(map(int, libc[1].split('.'))) < (2, 35):
+        raise RuntimeError('Requires glibc >= 2.35; never replace host glibc')
+    if str(root) != '/opt/vllm-runtime-0.32.0-cu130':
+        raise RuntimeError('Unexpected installation root')
+    if root.exists() or root.is_symlink(): raise RuntimeError('Existing runtime is preserved; select a fresh node/path release')
+    if os.geteuid() != 0: raise RuntimeError('This GOLD-style release requires root to create its private /opt directory')
+    if Path('/opt').is_symlink(): raise RuntimeError('Unexpected /opt symlink')
+    for name, item in manifest['files'].items():
+        if Path(name).name != name or name in ('', '.', '..'):
+            raise RuntimeError('Unsafe manifest filename')
+        path = payload / name
+        if not path.is_file() or path.stat().st_size != item['bytes'] or sha(path) != item['sha256']:
+            raise RuntimeError('Payload SHA256/size mismatch: ' + name)
+    archive = payload / 'runtime.tar.gz'
+    review = review_archive(archive, [str(root)])
+    if review != manifest['archive']: raise RuntimeError('Archive allowlist/member/size mismatch')
+    if shutil.disk_usage('/opt').free < review['unpacked_regular_file_bytes'] + 2 * 1024**3:
+        raise RuntimeError('Insufficient /opt disk')
+    subprocess.run(['tar', '--keep-old-files', '-xzf', str(archive), '-C', '/'], check=True)
+    command = ['bash', str(root / 'node/python-vllm.sh'), str(root / 'node/gates.py'),
+               'cpu', '--output', str(payload / 'node-cpu-qualification')]
+    subprocess.run(command, env={**os.environ, 'CUDA_VISIBLE_DEVICES': '-1'}, check=True, timeout=150)
+    print(json.dumps({'installed': str(root), 'cpu_passed': True, 'gpu_used': False,
+                      'company_gpu_qualification': 'pending assigned node/GPU'}), flush=True)
+
+
+if __name__ == '__main__': install(Path(__file__).absolute().parent)

releases/vllm-0.32.0-cu130-20261028-r1/manifest.json

@@ -0,0 +1,93 @@
+{
+  "protocol": "vllm-portable-runtime-v1",
+  "release": "vllm-0.32.0-cu130-20261028-r1",
+  "pins": {
+    "protocol": "vllm-portable-runtime-v1",
+    "release": "vllm-0.32.0-cu130-20261028-r1",
+    "vllm": "0.32.0",
+    "torch": "2.13.0",
+    "python": "3.12.12",
+    "uv": "0.12.7",
+    "modal_sdk": "1.6.1",
+    "base_image": "docker.io/nvidia/cuda:13.0.2-devel-ubuntu22.04@sha256:1c517d4fb96528c8999e14e6e6b16d7e2ff9ae8d194fd788d60fdc88e693e982",
+    "restore_image": "docker.io/library/ubuntu:22.04@sha256:e0f80c829509ef4df9e76bd8944eb7b8ec25cbb379b112a7f9448b2c77a77c9b",
+    "root": "/opt/vllm-runtime-0.32.0-cu130",
+    "python_root": "/opt/vllm-runtime-0.32.0-cu130/python",
+    "venv": "/opt/vllm-runtime-0.32.0-cu130/venv",
+    "project": "/opt/vllm-runtime-0.32.0-cu130/env",
+    "node": "/opt/vllm-runtime-0.32.0-cu130/node",
+    "support_libs": "/opt/vllm-runtime-0.32.0-cu130/lib",
+    "toolkit": "/opt/vllm-runtime-0.32.0-cu130/cuda",
+    "fixtures": "/opt/vllm-runtime-0.32.0-cu130/fixtures",
+    "min_glibc": "2.35",
+    "modal_profile": "lhtu05",
+    "additional_spend_cap_usd": 5,
+    "hf_repo": "codemaivanngu/vllm-portable-runtime",
+    "hf_private": false,
+    "qualification_gpu": "B200",
+    "qualification_scope": "Linux x86_64 runtime, synthetic dense BF16 inference and local HTTP serving on one B200; no company-node, production-model or multi-GPU qualification"
+  },
+  "archive": {
+    "members": 70230,
+    "unpacked_regular_file_bytes": 11041486896,
+    "targets": [
+      "/opt/vllm-runtime-0.32.0-cu130"
+    ]
+  },
+  "files": {
+    "CUDA-LICENSES.txt": {
+      "bytes": 1743247,
+      "sha256": "5e72ff86ba2dcda82ff75cb8788351703baec3191923f632f833cd5cbf005dd7"
+    },
+    "README.md": {
+      "bytes": 4061,
+      "sha256": "3ff20c283001e54bb2f20ff9ce12ea5344b7b5ae2624ea51630acc4bb5f153a0"
+    },
+    "archive_contract.py": {
+      "bytes": 1963,
+      "sha256": "694914d21aadcfe8c891bc92c8fe1072bf69ff6dc21c0c2ae00a1703231e0ad2"
+    },
+    "build-facts.json": {
+      "bytes": 848,
+      "sha256": "887a82b972a29b8bb99118eb2616233cb2024adadddc4083e7d1197f990de72c"
+    },
+    "download_release.py": {
+      "bytes": 5008,
+      "sha256": "f98613a7a4f8883f2f8a3234dac0973bc00002deb3d5ff6e319e31ad19d20f3d"
+    },
+    "install.py": {
+      "bytes": 2695,
+      "sha256": "e37c16fe6bdd925efae3f16974b49c9b6df169d9b011333b99a9f842f50304eb"
+    },
+    "node_gate.py": {
+      "bytes": 2519,
+      "sha256": "c43da09e054b7967e75a68137fa4619b925dde5988bcbba14f64da898e1a3ea0"
+    },
+    "pins.json": {
+      "bytes": 1245,
+      "sha256": "d56689414e3fa222ccf4a4c872b94430ab5dd02ff0b8e9cf37e62d4774dd3d6e"
+    },
+    "python-vllm.sh": {
+      "bytes": 1288,
+      "sha256": "1771ab395f426c977f1c3052d75bf35ce95015159f72a669d5ee9833dd67eee4"
+    },
+    "qualification.json": {
+      "bytes": 6325,
+      "sha256": "66f5fb0c01ddbee0d6d5913e69aa04e85ee4cd1438b87d4972b1b42f527396ba"
+    },
+    "runtime.tar.gz": {
+      "bytes": 5821293851,
+      "sha256": "b22e2ef9b1d1f1f2f233b9360bc82e8cb53b69c3d4811e3043167f0037db532b"
+    },
+    "uv.lock": {
+      "bytes": 378886,
+      "sha256": "213282f08d00ba473c6692aa62b39de4c07c7029f7279db62c87850c3d1e6cd9"
+    },
+    "vllm.sh": {
+      "bytes": 133,
+      "sha256": "2e93d80f0b6bab7d9d66436c18257526a72a05a6da8f537aeadad7e6b27d0b9e"
+    }
+  },
+  "qualification_scope": "Linux x86_64 runtime, synthetic dense BF16 inference and local HTTP serving on one B200; no company-node, production-model or multi-GPU qualification",
+  "company_status": "not run"
+}

releases/vllm-0.32.0-cu130-20261028-r1/node_gate.py

@@ -0,0 +1,43 @@
+"""Read-only physical-GPU UUID preflight; --run opts into the runtime canaries."""
+import argparse
+import csv
+import json
+import os
+from pathlib import Path
+import re
+import subprocess
+
+ROOT = '/opt/vllm-runtime-0.32.0-cu130'
+
+
+def selected_gpu(gpu_text, process_text, target):
+    fields = ('index', 'uuid', 'name', 'used_mib', 'total_mib', 'driver')
+    rows = [dict(zip(fields, [value.strip() for value in row])) for row in csv.reader(gpu_text.splitlines()) if row]
+    selected = [row for row in rows if row['uuid'] == target]
+    if len(selected) != 1: raise RuntimeError('Assigned GPU UUID does not uniquely exist')
+    row = selected[0]
+    occupants = [values for values in csv.reader(process_text.splitlines()) if values and values[0].strip() == target]
+    if occupants or int(row['used_mib']) >= 2048: raise RuntimeError('Assigned GPU is occupied; no process was stopped')
+    return row
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--node-label', required=True)
+    parser.add_argument('--gpu-uuid', required=True)
+    parser.add_argument('--output', required=True)
+    parser.add_argument('--run', action='store_true')
+    args = parser.parse_args()
+    if not re.fullmatch(r'[A-Za-z0-9._-]+', args.node_label): parser.error('Use the actual confirmed node label')
+    if not re.fullmatch(r'GPU-[0-9A-Fa-f-]{36}', args.gpu_uuid): parser.error('Use a physical assigned GPU UUID')
+    gpu_text = subprocess.check_output(['nvidia-smi', '--query-gpu=index,uuid,name,memory.used,memory.total,driver_version', '--format=csv,noheader,nounits'], text=True)
+    process_text = subprocess.check_output(['nvidia-smi', '--query-compute-apps=gpu_uuid,pid,process_name', '--format=csv,noheader'], text=True)
+    gpu = selected_gpu(gpu_text, process_text, args.gpu_uuid)
+    print(json.dumps({'node_label_from_user': args.node_label, 'assigned_gpu': gpu, 'mode': 'run' if args.run else 'read_only'}), flush=True)
+    if args.run:
+        output = Path(args.output); output.mkdir(parents=True, exist_ok=False)
+        for stage in ('cpu', 'cuda', 'infer', 'serve'):
+            with (output / (stage + '.log')).open('x') as log:
+                subprocess.run(['bash', ROOT + '/node/python-vllm.sh', ROOT + '/node/gates.py', stage,
+                    '--output', str(output / stage)], env={**os.environ, 'CUDA_VISIBLE_DEVICES': '-1' if stage == 'cpu' else args.gpu_uuid},
+                    stdout=log, stderr=subprocess.STDOUT, check=True, timeout=600)

releases/vllm-0.32.0-cu130-20261028-r1/pins.json

@@ -0,0 +1,26 @@
+{
+  "protocol": "vllm-portable-runtime-v1",
+  "release": "vllm-0.32.0-cu130-20261028-r1",
+  "vllm": "0.32.0",
+  "torch": "2.13.0",
+  "python": "3.12.12",
+  "uv": "0.12.7",
+  "modal_sdk": "1.6.1",
+  "base_image": "docker.io/nvidia/cuda:13.0.2-devel-ubuntu22.04@sha256:1c517d4fb96528c8999e14e6e6b16d7e2ff9ae8d194fd788d60fdc88e693e982",
+  "restore_image": "docker.io/library/ubuntu:22.04@sha256:e0f80c829509ef4df9e76bd8944eb7b8ec25cbb379b112a7f9448b2c77a77c9b",
+  "root": "/opt/vllm-runtime-0.32.0-cu130",
+  "python_root": "/opt/vllm-runtime-0.32.0-cu130/python",
+  "venv": "/opt/vllm-runtime-0.32.0-cu130/venv",
+  "project": "/opt/vllm-runtime-0.32.0-cu130/env",
+  "node": "/opt/vllm-runtime-0.32.0-cu130/node",
+  "support_libs": "/opt/vllm-runtime-0.32.0-cu130/lib",
+  "toolkit": "/opt/vllm-runtime-0.32.0-cu130/cuda",
+  "fixtures": "/opt/vllm-runtime-0.32.0-cu130/fixtures",
+  "min_glibc": "2.35",
+  "modal_profile": "lhtu05",
+  "additional_spend_cap_usd": 5,
+  "hf_repo": "codemaivanngu/vllm-portable-runtime",
+  "hf_private": false,
+  "qualification_gpu": "B200",
+  "qualification_scope": "Linux x86_64 runtime, synthetic dense BF16 inference and local HTTP serving on one B200; no company-node, production-model or multi-GPU qualification"
+}

releases/vllm-0.32.0-cu130-20261028-r1/python-vllm.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT=/opt/vllm-runtime-0.32.0-cu130
+test -x "$ROOT/venv/bin/python" || { echo 'Install the verified vLLM payload first' >&2; exit 2; }
+unset PYTHONHOME PYTHONPATH
+export PYTHONNOUSERSITE=1 PYTHONUNBUFFERED=1 TOKENIZERS_PARALLELISM=false
+export CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES:--1}"
+export CUDA_HOME="$ROOT/cuda"
+export PATH="$ROOT/venv/bin:$CUDA_HOME/bin:$PATH"
+export LD_LIBRARY_PATH="$ROOT/lib:$CUDA_HOME/lib64:${LD_LIBRARY_PATH:-}"
+# Match nvcc to its own headers. Do not inherit another image's CPATH/CUDA paths.
+unset C_INCLUDE_PATH CPLUS_INCLUDE_PATH CUDA_PATH
+export CPATH="$CUDA_HOME/include"
+export VLLM_PORTABLE_CACHE="${VLLM_PORTABLE_CACHE:-${XDG_CACHE_HOME:-/var/tmp}/vllm-portable-${UID}/0.32.0-cu130}"
+export XDG_CACHE_HOME="$VLLM_PORTABLE_CACHE"
+export VLLM_CACHE_ROOT="$VLLM_PORTABLE_CACHE/vllm" TRITON_CACHE_DIR="$VLLM_PORTABLE_CACHE/triton"
+export FLASHINFER_WORKSPACE_BASE="$VLLM_PORTABLE_CACHE/flashinfer" TORCH_EXTENSIONS_DIR="$VLLM_PORTABLE_CACHE/torch"
+export HF_HOME="${VLLM_PORTABLE_HF_HOME:-$VLLM_PORTABLE_CACHE/huggingface}"
+export HF_HUB_OFFLINE="${HF_HUB_OFFLINE:-1}" TRANSFORMERS_OFFLINE="${TRANSFORMERS_OFFLINE:-1}"
+export VLLM_NO_USAGE_STATS=1 HF_HUB_DISABLE_TELEMETRY=1
+exec "$ROOT/venv/bin/python" "$@"

releases/vllm-0.32.0-cu130-20261028-r1/qualification.json

@@ -0,0 +1,176 @@
+{
+  "cpu": {
+    "packages": {
+      "vllm": "0.32.0",
+      "torch": "2.13.0",
+      "transformers": "5.19.0",
+      "flashinfer-python": "0.7.0.post1",
+      "triton": "3.7.1"
+    },
+    "python": "3.12.12 (main, Feb 12 2026, 00:42:14) [Clang 21.1.4 ]",
+    "python_base": "/opt/vllm-runtime-0.32.0-cu130/python/cpython-3.12.12-linux-x86_64-gnu",
+    "wrapper_sha256": "1771ab395f426c977f1c3052d75bf35ce95015159f72a669d5ee9833dd67eee4",
+    "gates_sha256": "66d661aa6debd9ee29075543897af1ce94b32561674d8ede81f4ac6ba47e1af7",
+    "pins_sha256": "d56689414e3fa222ccf4a4c872b94430ab5dd02ff0b8e9cf37e62d4774dd3d6e",
+    "lock_sha256": "213282f08d00ba473c6692aa62b39de4c07c7029f7279db62c87850c3d1e6cd9",
+    "torch_cuda": "13.0",
+    "gpu_required": false,
+    "cli_help_scope": "checked by CUDA gate; upstream CLI probes NVML even for --help",
+    "stage": "cpu",
+    "elapsed_seconds": 4.7786136710000005,
+    "qualification_scope": "Linux x86_64 runtime, synthetic dense BF16 inference and local HTTP serving on one B200; no company-node, production-model or multi-GPU qualification",
+    "passed": true
+  },
+  "cuda": {
+    "packages": {
+      "vllm": "0.32.0",
+      "torch": "2.13.0",
+      "transformers": "5.19.0",
+      "flashinfer-python": "0.7.0.post1",
+      "triton": "3.7.1"
+    },
+    "python": "3.12.12 (main, Feb 12 2026, 00:42:14) [Clang 21.1.4 ]",
+    "python_base": "/opt/vllm-runtime-0.32.0-cu130/python/cpython-3.12.12-linux-x86_64-gnu",
+    "wrapper_sha256": "1771ab395f426c977f1c3052d75bf35ce95015159f72a669d5ee9833dd67eee4",
+    "gates_sha256": "66d661aa6debd9ee29075543897af1ce94b32561674d8ede81f4ac6ba47e1af7",
+    "pins_sha256": "d56689414e3fa222ccf4a4c872b94430ab5dd02ff0b8e9cf37e62d4774dd3d6e",
+    "lock_sha256": "213282f08d00ba473c6692aa62b39de4c07c7029f7279db62c87850c3d1e6cd9",
+    "gpu": "NVIDIA B200",
+    "capability": [
+      10,
+      0
+    ],
+    "native_rmsnorm": true,
+    "driver": "610.57.04",
+    "stage": "cuda",
+    "elapsed_seconds": 19.354250988,
+    "qualification_scope": "Linux x86_64 runtime, synthetic dense BF16 inference and local HTTP serving on one B200; no company-node, production-model or multi-GPU qualification",
+    "passed": true
+  },
+  "infer": {
+    "packages": {
+      "vllm": "0.32.0",
+      "torch": "2.13.0",
+      "transformers": "5.19.0",
+      "flashinfer-python": "0.7.0.post1",
+      "triton": "3.7.1"
+    },
+    "python": "3.12.12 (main, Feb 12 2026, 00:42:14) [Clang 21.1.4 ]",
+    "python_base": "/opt/vllm-runtime-0.32.0-cu130/python/cpython-3.12.12-linux-x86_64-gnu",
+    "wrapper_sha256": "1771ab395f426c977f1c3052d75bf35ce95015159f72a669d5ee9833dd67eee4",
+    "gates_sha256": "66d661aa6debd9ee29075543897af1ce94b32561674d8ede81f4ac6ba47e1af7",
+    "pins_sha256": "d56689414e3fa222ccf4a4c872b94430ab5dd02ff0b8e9cf37e62d4774dd3d6e",
+    "lock_sha256": "213282f08d00ba473c6692aa62b39de4c07c7029f7279db62c87850c3d1e6cd9",
+    "requests": 2,
+    "tokens_per_request": 8,
+    "token_ids": [
+      [
+        54,
+        53,
+        31,
+        31,
+        31,
+        31,
+        31,
+        31
+      ],
+      [
+        28,
+        28,
+        28,
+        28,
+        28,
+        44,
+        68,
+        3
+      ]
+    ],
+    "normal_compiled_engine": true,
+    "synthetic_random_weights": true,
+    "stage": "infer",
+    "elapsed_seconds": 125.49120856799999,
+    "qualification_scope": "Linux x86_64 runtime, synthetic dense BF16 inference and local HTTP serving on one B200; no company-node, production-model or multi-GPU qualification",
+    "passed": true
+  },
+  "serve": {
+    "packages": {
+      "vllm": "0.32.0",
+      "torch": "2.13.0",
+      "transformers": "5.19.0",
+      "flashinfer-python": "0.7.0.post1",
+      "triton": "3.7.1"
+    },
+    "python": "3.12.12 (main, Feb 12 2026, 00:42:14) [Clang 21.1.4 ]",
+    "python_base": "/opt/vllm-runtime-0.32.0-cu130/python/cpython-3.12.12-linux-x86_64-gnu",
+    "wrapper_sha256": "1771ab395f426c977f1c3052d75bf35ce95015159f72a669d5ee9833dd67eee4",
+    "gates_sha256": "66d661aa6debd9ee29075543897af1ce94b32561674d8ede81f4ac6ba47e1af7",
+    "pins_sha256": "d56689414e3fa222ccf4a4c872b94430ab5dd02ff0b8e9cf37e62d4774dd3d6e",
+    "lock_sha256": "213282f08d00ba473c6692aa62b39de4c07c7029f7279db62c87850c3d1e6cd9",
+    "models": {
+      "object": "list",
+      "data": [
+        {
+          "id": "portable-fixture",
+          "object": "model",
+          "created": 1793124855,
+          "owned_by": "vllm",
+          "root": "/opt/vllm-runtime-0.32.0-cu130/fixtures",
+          "parent": null,
+          "max_model_len": 128,
+          "permission": [
+            {
+              "id": "modelperm-9f0581941061b324",
+              "object": "model_permission",
+              "created": 1793124855,
+              "allow_create_engine": false,
+              "allow_sampling": true,
+              "allow_logprobs": true,
+              "allow_search_indices": false,
+              "allow_view": true,
+              "allow_fine_tuning": false,
+              "organization": "*",
+              "group": null,
+              "is_blocking": false
+            }
+          ]
+        }
+      ]
+    },
+    "completion": {
+      "id": "cmpl-9deb7a4eaab71aad",
+      "object": "text_completion",
+      "created": 1793124855,
+      "model": "portable-fixture",
+      "choices": [
+        {
+          "index": 0,
+          "text": " token54 token53 token31 token31 token31 token31 token31 token31",
+          "logprobs": null,
+          "finish_reason": "length",
+          "stop_reason": null,
+          "token_ids": null,
+          "prompt_logprobs": null,
+          "prompt_token_ids": null,
+          "routed_experts": null
+        }
+      ],
+      "service_tier": null,
+      "system_fingerprint": "vllm-0.32.0-6952f46e",
+      "usage": {
+        "prompt_tokens": 2,
+        "total_tokens": 10,
+        "completion_tokens": 8,
+        "prompt_tokens_details": null,
+        "completion_tokens_details": null
+      },
+      "kv_transfer_params": null,
+      "ec_transfer_params": null,
+      "metrics": null
+    },
+    "bound_to_loopback": true,
+    "stage": "serve",
+    "elapsed_seconds": 40.58435433300002,
+    "qualification_scope": "Linux x86_64 runtime, synthetic dense BF16 inference and local HTTP serving on one B200; no company-node, production-model or multi-GPU qualification",
+    "passed": true
+  }
+}

releases/vllm-0.32.0-cu130-20261028-r1/restore-cpu-receipt.json

@@ -0,0 +1,8 @@
+{
+  "pass": true,
+  "installer_exit_code": 0,
+  "restore_image": "docker.io/library/ubuntu:22.04@sha256:e0f80c829509ef4df9e76bd8944eb7b8ec25cbb379b112a7f9448b2c77a77c9b",
+  "base_had_cuda_toolkit": false,
+  "gpu_gates": false,
+  "elapsed_seconds": 234.295727668
+}

releases/vllm-0.32.0-cu130-20261028-r1/restore-gpu-receipt.json

@@ -0,0 +1,8 @@
+{
+  "pass": true,
+  "installer_exit_code": 0,
+  "restore_image": "docker.io/library/ubuntu:22.04@sha256:e0f80c829509ef4df9e76bd8944eb7b8ec25cbb379b112a7f9448b2c77a77c9b",
+  "base_had_cuda_toolkit": false,
+  "gpu_gates": true,
+  "elapsed_seconds": 233.742409607
+}

releases/vllm-0.32.0-cu130-20261028-r1/runtime.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b22e2ef9b1d1f1f2f233b9360bc82e8cb53b69c3d4811e3043167f0037db532b
+size 5821293851

releases/vllm-0.32.0-cu130-20261028-r1/vllm.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -euo pipefail
+exec bash /opt/vllm-runtime-0.32.0-cu130/node/python-vllm.sh -m vllm.entrypoints.cli.main "$@"