Enable centered-power vLLM prompt scoring and future hook at startup

snapshots/centered_startup_fix_20261012_172656/install_snapshot.py

@@ -0,0 +1,88 @@
+"""Install one immutable, hash-verified centered-power snapshot on cuhksz."""
+
+import ast
+import hashlib
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import yaml
+from huggingface_hub import snapshot_download
+
+
+def digest(data):
+    return hashlib.sha256(data).hexdigest()
+
+
+revision, prefix, manifest_hash = sys.argv[1:]
+staging = Path('/data/zhangyu/.sharpen-snapshots') / prefix.split('/')[-1]
+snapshot_download('zymatrix/sharpen', repo_type='dataset', revision=revision,
+                  allow_patterns=[prefix + '/*'], local_dir=staging)
+source = staging / prefix
+manifest_bytes = (source / 'manifest.json').read_bytes()
+if digest(manifest_bytes) != manifest_hash:
+    raise RuntimeError('Downloaded manifest hash differs from the uploaded manifest.')
+manifest = json.loads(manifest_bytes)
+target = Path(manifest['target_root'])
+if target != Path('/data/zhangyu/Sharpen-OPSD') or manifest['objective'] != 'centered_power_student':
+    raise ValueError('Unexpected installation target or objective.')
+
+# Verify the complete source and existing target before replacing any implementation file.
+installed_data = {}
+for relative, expected in manifest['files'].items():
+    relative_path = Path(relative)
+    if relative_path.is_absolute() or '..' in relative_path.parts:
+        raise ValueError('Snapshot file paths must be repository-relative.')
+    data = (source / relative).read_bytes()
+    if digest(data) != expected:
+        raise RuntimeError('Source hash mismatch: ' + relative)
+    if digest((target / relative).read_bytes()) != manifest['expected_target_hashes'][relative]:
+        raise RuntimeError('Target changed since inspection: ' + relative)
+    if relative.endswith('.py'):
+        ast.parse(data, filename=relative)
+    elif relative.endswith('.sh'):
+        subprocess.run(['bash', '-n', str(source / relative)], check=True)
+    elif relative.endswith('.yaml'):
+        yaml.safe_load(data)
+    for key, change in manifest['path_rewrites'].get(relative, {}).items():
+        config = yaml.safe_load(data)
+        if config.get(key) != change['before']:
+            raise RuntimeError('Unexpected source path setting: ' + key)
+        if key in config:
+            before = f"{key}: {change['before']}".encode()
+            after = f"{key}: {change['after']}".encode()
+            if data.count(before) != 1:
+                raise RuntimeError('Path rewrite must match one YAML entry: ' + key)
+            data = data.replace(before, after)
+        else:
+            data += f"\n{key}: {change['after']}\n".encode()
+    if relative.endswith('.yaml'):
+        yaml.safe_load(data)
+    installed_data[relative] = data
+for relative, expected in manifest['existing_dependencies'].items():
+    if digest((target / relative).read_bytes()) != expected:
+        raise RuntimeError('Existing dependency hash mismatch: ' + relative)
+
+for relative, data in installed_data.items():
+    destination = target / relative
+    temporary = destination.with_name(destination.name + '.centered-install-tmp')
+    temporary.write_bytes(data)
+    temporary.chmod(manifest['modes'][relative])
+    os.replace(temporary, destination)
+    if digest(destination.read_bytes()) != digest(data):
+        raise RuntimeError('Installed file hash mismatch: ' + relative)
+
+report = {
+    'revision': revision, 'snapshot_prefix': prefix, 'manifest_sha256': manifest_hash,
+    'source': str(source), 'target': str(target), 'objective': manifest['objective'],
+    'path_rewrites': manifest['path_rewrites'], 'source_hashes_verified': True,
+    'existing_dependencies_verified': True, 'syntax_checks': 'passed',
+    'installed_hashes': {relative: digest(data) for relative, data in installed_data.items()},
+    'launch_config': manifest['launch'],
+}
+report_path = target / 'logs' / ('sync_' + prefix.split('/')[-1] + '.json')
+report_path.write_text(json.dumps(report, indent=2) + '\n')
+print(json.dumps({'status': 'installed', 'revision': revision, 'files': len(installed_data),
+                  'report': str(report_path)}))

snapshots/centered_startup_fix_20261012_172656/manifest.json

@@ -0,0 +1,48 @@
+{
+  "objective": "centered_power_student",
+  "created_at": "2026-10-12T17:26:56.038350+08:00",
+  "repo": "zymatrix/sharpen",
+  "snapshot_prefix": "snapshots/centered_startup_fix_20261012_172656",
+  "target_root": "/data/zhangyu/Sharpen-OPSD",
+  "parent_revision": "49216ffd54a4e50ddf87142368cf09255b7a0ff3",
+  "files": {
+    "third_party/verl/verl/workers/rollout/vllm_rollout/vllm_async_server.py": "15ce26456f50cc285cbd0416d5062d9b7ba38205a4397b72b737513eeb2ecc21",
+    "third_party/verl/tests/workers/rollout/test_sps_vllm_contract_on_cpu.py": "ff9e4cf904a66b8dab90ee3cb7e0640add4e903c93b666d57589225cc34c2f1c"
+  },
+  "modes": {
+    "third_party/verl/verl/workers/rollout/vllm_rollout/vllm_async_server.py": 420,
+    "third_party/verl/tests/workers/rollout/test_sps_vllm_contract_on_cpu.py": 420
+  },
+  "expected_target_hashes": {
+    "third_party/verl/verl/workers/rollout/vllm_rollout/vllm_async_server.py": "f3370bbaf8d2f749c8cf279ad9f69e118bd26e56289e8d6dc6ed5252012ae632",
+    "third_party/verl/tests/workers/rollout/test_sps_vllm_contract_on_cpu.py": "d0a737c2b43cff835a5eee9ba8b43ab50049783f2e7925d3349468dfd3fb5ca1"
+  },
+  "existing_dependencies": {
+    "third_party/verl/verl/workers/config/model.py": "64e9f280833292315cc2d14a73782d00a24604151f819a46363252edd60daa5e",
+    "third_party/verl/verl/trainer/config/model/hf_model.yaml": "8325ec2a11fcabfa1fb3f5999f3f59d813fd9f1222933fad0a845e51ef35f753",
+    "third_party/verl/verl/utils/dataset/rl_dataset.py": "95e7bdb8514c70d545468ab6a280f2bb172e62e4a0bac77eeb3379975a393a0a",
+    "src/opsd_format.py": "d0a3d9c40b8a1c5f69853c9bd84f3993f17e1f2f09e387fc7fa81b349907af6c",
+    "src/verl_reward.py": "e5a0867add7be89551d6d2390e6056727442a1e5f6e3db1202e9f0d1a0c8552a",
+    "third_party/verl/verl/utils/tracking.py": "cdac58d4ce9e68ca8a941aea634e4ae7581ce01b82fc37ecf59b4b09a1b1297a",
+    "src/data_utils.py": "dc715ff0ac64ceafb5da93d09bf86c0a9fa7435916370a9dd38544f9db3f409f",
+    "src/verl_main.py": "4293e63d924307695b81da17a83838686bfc4332331b998ddf7fe8dfda6816fd"
+  },
+  "path_rewrites": {},
+  "installer_sha256": "379d97eeb3e432d5461eba443491ed4b6e5ed76881aca7da6ac4faac0a094732",
+  "launch": {
+    "fresh_base": true,
+    "model_path": "/data/zhangyu/model/Qwen3-4B",
+    "devices": [
+      4,
+      5,
+      6,
+      7
+    ],
+    "training_batch_size": 32,
+    "total_training_steps": 450,
+    "save_freq": 25,
+    "test_freq": 10,
+    "val_before_train": true
+  },
+  "reason": "Server startup still matched obsolete objective ess_power_student, skipping base prompt-scoring and future-weight hooks; first auxiliary scoring caused CUDA illegal access."
+}

snapshots/centered_startup_fix_20261012_172656/third_party/verl/tests/workers/rollout/test_sps_vllm_contract_on_cpu.py

@@ -0,0 +1,323 @@
+import pytest
+
+from verl.experimental.agent_loop.agent_loop import _validate_sps_sampling_params
+from verl.experimental.agent_loop.single_turn_agent_loop import (
+    _ensure_sps_outputs,
+    _validate_future_output,
+)
+from verl.workers.rollout.replica import TokenOutput
+
+
+def test_sps_n_sampling_requires_exact_count():
+    outputs = [TokenOutput(token_ids=[1], log_probs=[-0.1]) for _ in range(8)]
+    assert len(_ensure_sps_outputs(outputs, 8)) == 8
+    with pytest.raises(RuntimeError, match="expected 8"):
+        _ensure_sps_outputs(outputs[:7], 8)
+
+
+def test_non_eos_future_must_fill_fixed_horizon():
+    with pytest.raises(RuntimeError, match="exactly 3"):
+        _validate_future_output(TokenOutput(token_ids=[1, 2], log_probs=[-0.1, -0.2]), 3, {99})
+
+
+def test_eos_future_may_end_early_and_scores_eos():
+    tokens, log_probs = _validate_future_output(
+        TokenOutput(token_ids=[1, 99], log_probs=[-0.1, -0.2]), 3, {99}
+    )
+    assert tokens == [1, 99]
+    assert log_probs == [-0.1, -0.2]
+
+
+def test_future_rejects_tokens_after_first_eos():
+    with pytest.raises(RuntimeError, match="tokens after EOS"):
+        _validate_future_output(
+            TokenOutput(token_ids=[99, 1, 99], log_probs=[-0.1, -0.2, -0.3]), 3, {99}
+        )
+
+
+@pytest.mark.parametrize("parameter,value", [
+    ("top_p", 0.95), ("top_k", 20), ("min_p", 0.1), ("repetition_penalty", 1.1),
+    ("presence_penalty", 0.1), ("frequency_penalty", 0.1), ("min_tokens", 1), ("ignore_eos", True),
+])
+def test_future_requires_full_support_and_real_eos(parameter, value):
+    _validate_sps_sampling_params({"temperature": 0.5}, future_exponent=2)
+    with pytest.raises(ValueError):
+        _validate_sps_sampling_params({"temperature": 0.5, parameter: value}, future_exponent=2)
+    with pytest.raises(ValueError, match="temperature"):
+        _validate_sps_sampling_params({"temperature": 0.5})
+
+
+def _serving_method_for_cpu():
+    """Execute the real request method with a fake vLLM engine (no GPU package)."""
+    import ast
+    from pathlib import Path
+    from types import SimpleNamespace
+
+    path = Path(__file__).parents[3] / "verl/workers/rollout/vllm_rollout/vllm_async_server.py"
+    tree = ast.parse(path.read_text())
+    method = next(node for node in ast.walk(tree) if isinstance(node, ast.AsyncFunctionDef)
+                  and node.name == "generate_n")
+    future = ast.ImportFrom(module="__future__", names=[ast.alias(name="annotations")], level=0)
+    module = ast.Module(body=[future, method], type_ignores=[])
+    namespace = {
+        "normalize_token_ids": list, "qwen2_5_vl_dedup_image_tokens": lambda tokens, _: tokens,
+        "TokenOutput": TokenOutput, "TokensPrompt": lambda **kwargs: kwargs,
+        "SamplingParams": lambda **kwargs: SimpleNamespace(
+            n=kwargs.pop("n", 1), prompt_logprobs=kwargs.pop("prompt_logprobs", None), **kwargs),
+        "RequestOutputKind": SimpleNamespace(FINAL_ONLY="final_only"),
+        "VLLM_LORA_INT_ID": 1, "VLLM_LORA_NAME": "student", "VLLM_LORA_PATH": "adapter",
+        "LoRARequest": lambda **kwargs: kwargs,
+        "extract_prompt_logprobs": lambda **kwargs: None,
+    }
+    exec(compile(ast.fix_missing_locations(module), str(path), "exec"), namespace)
+    return namespace["generate_n"]
+
+
+@pytest.mark.parametrize("objective,targets,expected", [
+    ("centered_power_student", "all-linear", {"vocab_size": 10, "crpd_base_scoring": True}),
+    (None, "all-linear", {"vocab_size": 10}),
+    ("centered_power_student", "q_proj", None),
+])
+def test_actual_server_startup_enables_centered_power_prompt_and_future_patch(objective, targets, expected):
+    import ast
+    import asyncio
+    import inspect
+    from pathlib import Path
+    from types import SimpleNamespace
+
+    from omegaconf import OmegaConf
+
+    # Run the real startup path through its first RPC; HTTP startup needs no CPU stub.
+    path = Path(__file__).parents[3] / "verl/workers/rollout/vllm_rollout/vllm_async_server.py"
+    method = next(node for node in ast.walk(ast.parse(path.read_text()))
+                  if isinstance(node, ast.AsyncFunctionDef) and node.name == "run_server")
+
+    class InitializationComplete(Exception):
+        pass
+
+    class Engine:
+        def __init__(self):
+            self.calls = []
+            self.cache_reset = False
+
+        async def reset_mm_cache(self):
+            self.cache_reset = True
+
+        async def collective_rpc(self, **kwargs):
+            self.calls.append(kwargs)
+            raise InitializationComplete
+
+    engine = Engine()
+    engine_args = SimpleNamespace(create_engine_config=lambda **kwargs: SimpleNamespace(
+        parallel_config=SimpleNamespace()))
+    namespace = {
+        "inspect": inspect,
+        "AsyncEngineArgs": SimpleNamespace(from_cli_args=lambda args: engine_args),
+        "AsyncLLM": SimpleNamespace(from_vllm_config=lambda **kwargs: engine),
+        "UsageContext": SimpleNamespace(OPENAI_API_SERVER="server"),
+    }
+    future = ast.ImportFrom(module="__future__", names=[ast.alias(name="annotations")], level=0)
+    module = ast.fix_missing_locations(ast.Module(body=[future, method], type_ignores=[]))
+    exec(compile(module, str(path), "exec"), namespace)
+    server = SimpleNamespace(
+        _dp_master_port=1234, config=OmegaConf.create({"custom": {"objective": objective}}),
+        model_config=SimpleNamespace(target_modules=targets, tokenizer=list(range(10))),
+    )
+    if expected is None:
+        with pytest.raises(ValueError, match="all-linear"):
+            asyncio.run(namespace["run_server"](server, SimpleNamespace()))
+        assert not engine.calls
+    else:
+        with pytest.raises(InitializationComplete):
+            asyncio.run(namespace["run_server"](server, SimpleNamespace()))
+        assert engine.calls == [{"method": "monkey_patch_model", "kwargs": expected}]
+    assert engine.cache_reset
+
+
+def test_actual_serving_method_requires_loaded_student_adapter_and_allows_explicit_base():
+    import asyncio
+    from types import SimpleNamespace
+
+    from omegaconf import OmegaConf
+
+    class Engine:
+        loaded = False
+
+        def __init__(self):
+            self.requests = []
+
+        async def list_loras(self):
+            return [1] if self.loaded else []
+
+        async def generate(self, **kwargs):
+            self.requests.append(kwargs)
+            yield SimpleNamespace(outputs=[SimpleNamespace(
+                index=index, token_ids=[7], logprobs=[{7: SimpleNamespace(logprob=-0.2 - index * 0.1)}],
+                finish_reason="length", num_preempted=0,
+            ) for index in range(kwargs["sampling_params"].n)])
+
+    async def exercise():
+        engine = Engine()
+        server = SimpleNamespace(
+            config=OmegaConf.create({"max_model_len": 20, "prompt_length": 4, "response_length": 8,
+                                     "enable_rollout_routing_replay": False, "logprobs_mode": "processed_logprobs"}),
+            model_config=SimpleNamespace(processor=None), engine=engine, lora_as_adapter=True, global_steps=0,
+        )
+        generate = _serving_method_for_cpu()
+        params = {"max_tokens": 1, "use_lora": True, "crpd_require_adapter": True, "logprobs": True}
+        with pytest.raises(RuntimeError, match="refusing base fallback"):
+            await generate(server, [1, 2], params, "student")
+        assert not engine.requests
+        base = await generate(server, [1, 2], {**params, "use_lora": False}, "base")
+        assert engine.requests[-1]["lora_request"] is None
+        assert base[0].log_probs == [-0.2]
+        engine.loaded = True
+        await generate(server, [1, 2], params, "student")
+        assert engine.requests[-1]["lora_request"]["lora_int_id"] == 1
+        with pytest.raises(ValueError, match="only 18 fit"):
+            await generate(server, [1, 2], {**params, "max_tokens": 19, "sps_strict_context": True}, "long")
+        assert len(engine.requests) == 2
+        future = {**params, "use_lora": False, "power_future_exponent": 2, "temperature": 0.5}
+        output = (await generate(server, [1, 2], future, "future"))[0]
+        assert engine.requests[-1]["lora_request"] is None
+        assert not hasattr(engine.requests[-1]["sampling_params"], "power_future_exponent")
+        assert engine.requests[-1]["sampling_params"].extra_args == {"power_future_exponent": 2.0}
+        assert output.extra_fields["decode_logprobs_mode"] == "power_log_weights"
+        assert output.extra_fields["future_log_power_weights"] == [-0.2]
+        assert output.log_probs is None
+        futures = await generate(server, [1, 2], {**future, "n": 2}, "two_futures")
+        assert futures[0].extra_fields is not futures[1].extra_fields
+        assert futures[0].extra_fields["future_log_power_weights"] == [-0.2]
+        assert futures[1].extra_fields["future_log_power_weights"] == [pytest.approx(-0.3)]
+        with pytest.raises(ValueError, match="frozen-base"):
+            await generate(server, [1, 2], {**future, "use_lora": True}, "wrong_adapter")
+        with pytest.raises(ValueError, match="temperature"):
+            await generate(server, [1, 2], {**future, "temperature": 1}, "wrong_temperature")
+        server.config.logprobs_mode = "raw_logprobs"
+        with pytest.raises(ValueError, match="processed proposal"):
+            await generate(server, [1, 2], future, "wrong_mode")
+        server.config.logprobs_mode = "processed_logprobs"
+        output = (await generate(server, [1, 2], {**params, "use_lora": False, "prompt_logprobs": 0}, "score"))[0]
+        assert output.extra_fields["prompt_logprobs_mode"] == "raw_logprobs"
+        server.lora_as_adapter = False
+        with pytest.raises(RuntimeError, match="unmerged"):
+            await generate(server, [1, 2], params, "merged")
+
+    asyncio.run(exercise())
+
+
+def test_power_sampler_keeps_selected_tokens_and_other_rows_logprobs_with_batch_reordering():
+    import ast
+    from pathlib import Path
+    from types import SimpleNamespace
+
+    import torch
+
+    path = Path(__file__).parents[3] / "verl/workers/rollout/vllm_rollout/utils.py"
+    node = next(node for node in ast.walk(ast.parse(path.read_text()))
+                if isinstance(node, ast.FunctionDef) and node.name == "patch_power_future_sampler")
+    namespace = {"torch": torch}
+    exec(compile(ast.fix_missing_locations(ast.Module(body=[node], type_ignores=[])), str(path), "exec"), namespace)
+
+    class Sampler(torch.nn.Module):
+        def forward(self, logits, metadata):
+            logits.div_(metadata.temperature.unsqueeze(-1))
+            proposal = logits.log_softmax(-1)
+            tokens = torch.multinomial(proposal.exp(), 1)
+            return SimpleNamespace(sampled_token_ids=tokens, logprobs_tensors=SimpleNamespace(
+                logprobs=proposal.gather(-1, tokens)))
+
+    runner = SimpleNamespace(
+        sampler=Sampler(), input_batch=SimpleNamespace(req_ids=["student", "future", "validation"]),
+        requests={key: SimpleNamespace(sampling_params=SimpleNamespace(
+            extra_args={"power_future_exponent": 2.0} if key == "future" else None,
+        )) for key in ["student", "future", "validation"]},
+    )
+    namespace["patch_power_future_sampler"](runner)
+    patched = runner.sampler.forward
+    namespace["patch_power_future_sampler"](runner)
+    assert runner.sampler.forward is patched
+    for request_ids, temperatures, future_row in [
+        (["student", "future", "validation"], [1.0, 0.5, 0.7], 1),
+        (["future", "validation", "student"], [0.5, 0.7, 1.0], 0),
+    ]:
+        runner.input_batch.req_ids = request_ids
+        logits = torch.tensor([[1.0, -0.5, 0.3], [-0.8, 1.2, 0.2], [0.2, 0.8, -0.6]])
+        metadata = SimpleNamespace(temperature=torch.tensor(temperatures))
+        torch.manual_seed(17)
+        reference = Sampler()(logits.clone(), metadata)
+        torch.manual_seed(17)
+        actual = runner.sampler(logits.clone(), metadata)
+        torch.testing.assert_close(actual.sampled_token_ids, reference.sampled_token_ids)
+        raw = logits.log_softmax(-1).gather(-1, actual.sampled_token_ids)
+        expected = 2 * raw[future_row] - reference.logprobs_tensors.logprobs[future_row]
+        torch.testing.assert_close(actual.logprobs_tensors.logprobs[future_row], expected)
+        ordinary = [index for index in range(3) if index != future_row]
+        torch.testing.assert_close(actual.logprobs_tensors.logprobs[ordinary],
+                                   reference.logprobs_tensors.logprobs[ordinary])
+
+
+@pytest.mark.parametrize("wrapped", [False, True])
+def test_crpd_prompt_scoring_bypasses_unused_lora_logits_and_preserves_transformer_adapters(monkeypatch, wrapped):
+    import ast
+    import sys
+    from pathlib import Path
+    from types import ModuleType, SimpleNamespace
+
+    class LogitsProcessorWithLoRA:
+        def __init__(self, base_layer):
+            self.base_layer = base_layer
+
+        def __call__(self, lm_head, rows):
+            if len(rows) > 1:
+                raise RuntimeError("decode LoRA mapping is too short for prompt rows")
+            return self.base_layer(lm_head.base_layer, rows)
+
+    module = ModuleType("vllm.lora.layers.logits_processor")
+    module.LogitsProcessorWithLoRA = LogitsProcessorWithLoRA
+    monkeypatch.setitem(sys.modules, module.__name__, module)
+    path = Path(__file__).parents[3] / "verl/workers/rollout/vllm_rollout/utils.py"
+    tree = ast.parse(path.read_text())
+    method = next(node for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)
+                  and node.name == "monkey_patch_model")
+    namespace = {
+        "monkey_patch_compute_logits": lambda *_: None,
+        "patch_vllm_moe_model_weight_loader": lambda *_: None,
+        "patch_power_future_sampler": lambda *_: None,
+        "logger": SimpleNamespace(info=lambda *_: None),
+    }
+    exec(compile(ast.fix_missing_locations(ast.Module(body=[method], type_ignores=[])), str(path), "exec"), namespace)
+    base = lambda lm_head, rows: lm_head.quant_method.apply(rows)
+    base_head = SimpleNamespace(quant_method=SimpleNamespace(apply=lambda rows: [value * 2 for value in rows]))
+    adapter = object()
+
+    class Model:
+        def __init__(self):
+            self.logits_processor = LogitsProcessorWithLoRA(base)
+            self.lm_head = SimpleNamespace(base_layer=base_head)
+            self.transformer_adapter = adapter
+
+        def compute_logits(self, rows):
+            return self.logits_processor(self.lm_head, rows)
+
+    class CUDAGraphWrapper:
+        # vLLM delegates reads, but assignments stay on the wrapper.
+        def __init__(self, runnable):
+            self.runnable = runnable
+
+        def __getattr__(self, name):
+            return getattr(self.runnable, name)
+
+    model = Model()
+    runner_model = CUDAGraphWrapper(model) if wrapped else model
+    worker = SimpleNamespace(model_runner=SimpleNamespace(model=runner_model, get_model=lambda: model))
+    with pytest.raises(RuntimeError, match="too short"):
+        runner_model.compute_logits([1, 2, 3])
+    namespace["monkey_patch_model"](worker, 10)
+    assert isinstance(model.logits_processor, LogitsProcessorWithLoRA)
+    namespace["monkey_patch_model"](worker, 10, crpd_base_scoring=True)
+    assert runner_model.compute_logits([1, 2, 3]) == [2, 4, 6]
+    assert model.transformer_adapter is adapter
+    assert model.lm_head is base_head
+    namespace["monkey_patch_model"](worker, 10, crpd_base_scoring=True)
+    assert model.logits_processor is base

snapshots/centered_startup_fix_20261012_172656/third_party/verl/verl/workers/rollout/vllm_rollout/vllm_async_server.py

@@ -0,0 +1,1108 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import argparse
+import asyncio
+import inspect
+import json
+import logging
+import os
+from pprint import pprint
+from typing import Any, Callable, Optional
+
+import ray
+import vllm.entrypoints.cli.serve
+from packaging import version
+from ray.actor import ActorHandle
+from vllm import SamplingParams
+from vllm.engine.arg_utils import AsyncEngineArgs
+from vllm.entrypoints.cli.serve import run_headless
+from vllm.entrypoints.openai.api_server import build_app, init_app_state
+from vllm.inputs import TokensPrompt
+from vllm.lora.request import LoRARequest
+from vllm.outputs import RequestOutput
+from vllm.sampling_params import RequestOutputKind
+from vllm.usage.usage_lib import UsageContext
+from vllm.v1.engine.async_llm import AsyncLLM
+
+from verl.utils.config import omega_conf_to_dataclass
+from verl.utils.device import get_resource_name, get_visible_devices_keyword, is_torch_npu_available
+from verl.utils.net_utils import get_free_port, is_valid_ipv6_address
+from verl.utils.profiler import DistProfiler, build_vllm_profiler_args
+from verl.utils.tokenizer import normalize_token_ids
+from verl.utils.vllm.vllm_fp8_utils import apply_vllm_fp8_patches
+from verl.workers.config import HFModelConfig, RolloutConfig
+from verl.workers.rollout.replica import RolloutMode, RolloutReplica, TokenOutput
+from verl.workers.rollout.utils import get_max_position_embeddings, qwen2_5_vl_dedup_image_tokens, run_uvicorn
+from verl.workers.rollout.vllm_rollout.utils import (
+    VLLM_LORA_INT_ID,
+    VLLM_LORA_NAME,
+    VLLM_LORA_PATH,
+    SuppressSignalInThread,
+    build_cli_args_from_config,
+    extract_prompt_logprobs,
+    get_vllm_max_lora_rank,
+)
+
+_VLLM_VERSION = version.parse(vllm.__version__)
+
+if _VLLM_VERSION > version.parse("0.11.0"):
+    from vllm.utils.argparse_utils import FlexibleArgumentParser
+
+    if _VLLM_VERSION == version.parse("0.12.0"):
+        from vllm.entrypoints.harmony_utils import get_encoding
+
+    elif _VLLM_VERSION >= version.parse("0.13.0"):
+        from vllm.entrypoints.openai.parser.harmony_utils import get_encoding
+
+    else:
+        get_encoding = None
+
+    if get_encoding is not None and os.getenv("VERL_USE_GPT_OSS", "0") == "1":
+        get_encoding()
+else:
+    from vllm.utils import FlexibleArgumentParser
+
+
+logger = logging.getLogger(__file__)
+logger.setLevel(logging.INFO)
+
+
+class vLLMHttpServer:
+    """vLLM http server in single node, this is equivalent to launch server with command line:
+    ```
+    vllm serve --tensor-parallel-size=8 ...
+    ```
+    """
+
+    def __init__(
+        self,
+        config,
+        model_config,
+        rollout_mode: RolloutMode,
+        workers: list[ActorHandle],
+        replica_rank: int,
+        node_rank: int,
+        gpus_per_node: int,
+        nnodes: int,
+        cuda_visible_devices: str,
+    ):
+        """
+        Args:
+            config (RolloutConfig): full config.
+            model_config (HFModelConfig): model config.
+            rollout_mode (RolloutMode): rollout mode.
+            replica_rank (int): replica rank, a replica may contain multiple nodes.
+            node_rank (int): node rank.
+            gpus_per_node (int): number of gpus per node.
+            nnodes (int): number of nodes.
+            cuda_visible_devices (str): cuda visible devices.
+        """
+        os.environ[get_visible_devices_keyword()] = cuda_visible_devices
+
+        self.config = self._init_config(config)
+        self.model_config = self._init_model_config(model_config)
+        self._validate_configs()
+
+        self.rollout_mode = rollout_mode
+        self.workers = workers
+
+        self.replica_rank = replica_rank
+        self.node_rank = node_rank
+        self.gpus_per_node = gpus_per_node
+        self.nnodes = nnodes
+        # model weights version, set by ServerAdapter when update weights.
+        self.global_steps = None
+
+        if self.rollout_mode != RolloutMode.HYBRID and self.config.load_format == "dummy":
+            logger.warning(f"rollout mode is {self.rollout_mode}, load_format is dummy, set to auto")
+            self.config.load_format = "auto"
+
+        # used for http server
+        self._server_address = ray.util.get_node_ip_address().strip("[]")
+        self._server_port = None
+
+        # used for controlling vllm server profiler
+        profiler_config = self.config.profiler
+        tool_config = None
+        if profiler_config is not None:
+            if profiler_config.tool in ["torch", "npu"]:
+                tool_config = omega_conf_to_dataclass((profiler_config.tool_config or {}).get(profiler_config.tool))
+            else:
+                logger.warning(f"agent loop only support torch and npu profiler, got {profiler_config.tool}")
+                profiler_config = None
+        self.profiler_controller = DistProfiler(self.replica_rank, config=profiler_config, tool_config=tool_config)
+
+        # used for data parallel: --data-parallel-address, --data-parallel-rpc-port
+        if self.node_rank == 0:
+            self._master_address = self._server_address
+            # used for torch.distributed.init_process_group
+            self._master_port, self._master_sock = get_free_port(self._server_address, with_alive_sock=True)
+            # used for data parallel: --data-parallel-address, --data-parallel-rpc-port
+            self._dp_rpc_port, self._dp_rpc_sock = get_free_port(self._server_address, with_alive_sock=True)
+            self._dp_master_port, self._dp_master_sock = get_free_port(self._server_address, with_alive_sock=True)
+        else:
+            self._master_address = None
+            self._master_port = None
+            self._dp_rpc_port = None
+            self._dp_master_port = None
+
+        self._post_init(cuda_visible_devices)
+
+    def get_master_address(self):
+        """Get master address and port for data parallel.
+        Returns:
+            tuple: (master_address, master_port, dp_rpc_port)
+        """
+        return self._master_address, self._master_port, self._dp_rpc_port
+
+    def get_server_address(self):
+        """Get http server address and port."""
+        assert self._server_port is not None, "http server is not launched, port is None"
+        return self._server_address, self._server_port
+
+    @property
+    def lora_as_adapter(self) -> bool:
+        return (
+            self.model_config.lora_rank > 0 or self.model_config.lora.get("rank", 0) > 0
+        ) and not self.model_config.lora.get("merge", False)
+
+    async def collective_rpc(
+        self,
+        method: str | Callable,
+        timeout: float | None = None,
+        args: tuple = (),
+        kwargs: dict[str, Any] | None = None,
+    ):
+        await self.engine.collective_rpc(
+            method=method,
+            timeout=timeout,
+            args=args,
+            kwargs=kwargs,
+        )
+
+    async def launch_server(self, master_address: str = None, master_port: int = None, dp_rpc_port: int = None):
+        if self.node_rank != 0:
+            assert master_address and master_port and dp_rpc_port, (
+                "non-master node should provide master_address, master_port and dp_rpc_port"
+            )
+            self._master_address = master_address
+            self._master_port = master_port
+            self._dp_rpc_port = dp_rpc_port
+
+        # 1. setup vllm serve cli args
+        engine_kwargs = self.config.get("engine_kwargs", {}).get(self._get_engine_kwargs_key(), {}) or {}
+        engine_kwargs = {key: val for key, val in engine_kwargs.items() if val is not None}
+        if self.config.get("limit_images", None):  # support for multi-image data
+            engine_kwargs["limit_mm_per_prompt"] = {"image": self.config.get("limit_images")}
+        if self.config.cudagraph_capture_sizes:
+            engine_kwargs["cuda_graph_sizes"] = self.config.cudagraph_capture_sizes
+
+        self._preprocess_engine_kwargs(engine_kwargs)
+
+        # Override default generation config from hugging face model config,
+        # user can still override them by passing kwargs in each request.
+        override_generation_config = self._get_override_generation_config()
+        logger.info(f"override_generation_config: {override_generation_config}")
+
+        logger.info(f"enable_sleep_mode: {self.config.enable_sleep_mode}")
+        if not self.config.enable_sleep_mode:
+            from verl.utils.device import set_expandable_segments
+
+            set_expandable_segments(True)
+
+        quantization, hf_overrides = self._apply_quantization()
+
+        compilation_config = engine_kwargs.pop("compilation_config", None) or {}
+        if isinstance(compilation_config, str):
+            compilation_config = json.loads(compilation_config)
+        compilation_config.setdefault("cudagraph_mode", "FULL_AND_PIECEWISE")
+
+        # FULL cuda graph is not yet supported with DCP, downgrade to PIECEWISE
+        dcp_size = engine_kwargs.get("decode_context_parallel_size", 1) or 1
+        if dcp_size > 1 and compilation_config["cudagraph_mode"] == "FULL_AND_PIECEWISE":
+            logger.warning(
+                "FULL cuda graph is not supported with DCP (decode_context_parallel_size=%d), "
+                "downgrading cudagraph_mode to PIECEWISE.",
+                dcp_size,
+            )
+            compilation_config["cudagraph_mode"] = "PIECEWISE"
+
+        compilation_config = json.dumps(compilation_config)
+        args = {
+            "dtype": self.config.dtype,
+            "load_format": self.config.load_format,
+            "skip_tokenizer_init": False,
+            "distributed_executor_backend": "mp",
+            "worker_extension_cls": self._get_worker_extension_cls(),
+            "trust_remote_code": self.model_config.trust_remote_code,
+            "max_model_len": self.config.max_model_len,
+            "max_num_seqs": self.config.max_num_seqs,
+            "enable_chunked_prefill": self.config.enable_chunked_prefill,
+            "max_num_batched_tokens": self.config.max_num_batched_tokens,
+            "enable_prefix_caching": self.config.enable_prefix_caching,
+            "enable_sleep_mode": self.config.enable_sleep_mode,
+            "logprobs_mode": self.config.logprobs_mode,
+            "enforce_eager": self.config.enforce_eager,
+            "gpu_memory_utilization": self.config.gpu_memory_utilization,
+            "disable_log_stats": self.config.disable_log_stats,
+            "tensor_parallel_size": self.config.tensor_model_parallel_size,
+            "seed": self.replica_rank + self.config.get("seed", 0),
+            "override_generation_config": json.dumps(override_generation_config),
+            "quantization": quantization,
+            "hf_overrides": hf_overrides,
+            "scheduling_policy": self.config.scheduling_policy,
+            "compilation_config": compilation_config,
+            **engine_kwargs,
+        }
+
+        # update profiler args
+        profiler_args = build_vllm_profiler_args(
+            self.profiler_controller.config, self.profiler_controller.tool_config, self.replica_rank
+        )
+        if _VLLM_VERSION >= version.parse("0.13.0"):
+            # vLLM >= 0.13.0 supports profiler config via CLI args; env vars still work but will be deprecated
+            args.update(profiler_args)
+
+        if self.config.prometheus.enable:
+            if self.config.prometheus.served_model_name:
+                # Extract model name from path if it's a full path
+                served_model_name = self.config.prometheus.served_model_name
+                if "/" in served_model_name:
+                    # If it's a full path, extract the last part as model name
+                    served_model_name = served_model_name.split("/")[-1]
+                args["served_model_name"] = served_model_name
+
+        # mtp (None for diffusion models; only LLM models use speculative decoding)
+        if self.config.mtp is not None and self.config.mtp.enable and self.config.mtp.enable_rollout:
+            speculative_config = {
+                "method": self.config.mtp.method,
+                "num_speculative_tokens": self.config.mtp.num_speculative_tokens,
+            }
+            args["speculative_config"] = speculative_config
+
+        if self.config.data_parallel_size > 1:
+            assert self.gpus_per_node % self.config.tensor_model_parallel_size == 0, (
+                "gpus_per_node should be divisible by tensor_model_parallel_size"
+            )
+            data_parallel_size_local = self.gpus_per_node // self.config.tensor_model_parallel_size
+            assert len(self.workers) == data_parallel_size_local * self.config.tensor_model_parallel_size, (
+                f"num workers ({len(self.workers)}) should be equal to "
+                f"dp_size_local ({data_parallel_size_local}) * tp_size ({self.config.tensor_model_parallel_size})"
+            )
+            dp_args = {
+                "data_parallel_size": self.config.data_parallel_size,
+                "data_parallel_size_local": data_parallel_size_local,
+                "data_parallel_start_rank": self.node_rank * data_parallel_size_local,
+                "data_parallel_address": self._master_address,
+                "data_parallel_rpc_port": self._dp_rpc_port,
+            }
+            args.update(dp_args)
+
+        args.update({"enable_expert_parallel": self.config.expert_parallel_size > 1})
+
+        # used for torch.distributed.init_process_group
+        if self.nnodes > 1:
+            args.update(
+                {
+                    "master_addr": self._master_address,
+                    "master_port": self._master_port,
+                    "node_rank": self.node_rank,
+                    "nnodes": self.nnodes,
+                    "data_parallel_address": self._master_address,
+                    "data_parallel_rpc_port": self._dp_rpc_port,
+                }
+            )
+
+        # update lora-related args
+        lora_rank = self.model_config.lora.get("rank", 0)
+        if lora_rank <= 0:
+            lora_rank = (
+                self.model_config.lora_rank
+            )  # FIXME: fallback to lora_rank for now, we should unify lora settings.
+
+        if self.model_config.lora.get("merge", False):
+            lora_rank = 0
+
+        if lora_rank > 0:
+            lora_args = {
+                "enable_lora": True,
+                "max_loras": 1,
+                "max_lora_rank": get_vllm_max_lora_rank(lora_rank),
+            }
+            if self.model_config.lora.get("fully_sharded_loras", False):
+                lora_args["fully_sharded_loras"] = True
+            args.update(lora_args)
+
+        if self.config.enable_rollout_routing_replay:
+            args.update({"enable_return_routed_experts": True})
+
+        server_args = ["serve", self.model_config.local_path] + build_cli_args_from_config(args)
+
+        if self.replica_rank == 0:
+            pprint(server_args)
+
+        CMD_MODULES = self._get_cli_modules()
+        parser = FlexibleArgumentParser(description=self._get_cli_description())
+        subparsers = parser.add_subparsers(required=False, dest="subparser")
+        cmds = {}
+        for cmd_module in CMD_MODULES:
+            new_cmds = cmd_module.cmd_init()
+            for cmd in new_cmds:
+                cmd.subparser_init(subparsers).set_defaults(dispatch_function=cmd.cmd)
+                cmds[cmd.name] = cmd
+        server_args = parser.parse_args(args=server_args)
+        server_args.model = server_args.model_tag
+        if server_args.subparser in cmds:
+            cmds[server_args.subparser].validate(server_args)
+
+        # 3. launch server
+        if self.node_rank == 0:
+            await self.run_server(server_args)
+        else:
+            await self.run_headless(server_args)
+
+    async def run_server(self, args: argparse.Namespace):
+        engine_args = AsyncEngineArgs.from_cli_args(args)
+        usage_context = UsageContext.OPENAI_API_SERVER
+        vllm_config = engine_args.create_engine_config(usage_context=usage_context)
+        vllm_config.parallel_config.data_parallel_master_port = self._dp_master_port
+
+        fn_args = set(dict(inspect.signature(AsyncLLM.from_vllm_config).parameters).keys())
+        kwargs = {}
+        if "enable_log_requests" in fn_args:
+            kwargs["enable_log_requests"] = engine_args.enable_log_requests
+        if "disable_log_stats" in fn_args:
+            kwargs["disable_log_stats"] = engine_args.disable_log_stats
+
+        engine_client = AsyncLLM.from_vllm_config(vllm_config=vllm_config, usage_context=usage_context, **kwargs)
+
+        # Don't keep the dummy data in memory
+        await engine_client.reset_mm_cache()
+        crpd_base_scoring = (self.config.custom or {}).get("objective") == "centered_power_student"
+        if crpd_base_scoring and self.model_config.target_modules != "all-linear":
+            raise ValueError("CRPD prompt scoring requires all-linear LoRA targets (excluding lm_head).")
+        patch_kwargs = {"vocab_size": len(self.model_config.tokenizer)}
+        if crpd_base_scoring:
+            patch_kwargs["crpd_base_scoring"] = True
+        await engine_client.collective_rpc(
+            method="monkey_patch_model", kwargs=patch_kwargs
+        )
+
+        build_app_sig = inspect.signature(build_app)
+        supported_tasks: tuple[Any, ...] = ()
+        if "supported_tasks" in build_app_sig.parameters:
+            supported_tasks = await engine_client.get_supported_tasks()
+            app = build_app(args, supported_tasks)
+        else:
+            app = build_app(args)
+
+        init_app_sig = inspect.signature(init_app_state)
+        if "vllm_config" in init_app_sig.parameters:
+            await init_app_state(engine_client, vllm_config, app.state, args)
+        elif "supported_tasks" in init_app_sig.parameters:
+            await init_app_state(engine_client, app.state, args, supported_tasks)
+        else:
+            await init_app_state(engine_client, app.state, args)
+        if self.replica_rank == 0 and self.node_rank == 0:
+            logger.info(f"Initializing a V1 LLM engine with config: {vllm_config}")
+
+        self.engine = engine_client
+        self._server_port, self._server_task = await run_uvicorn(app, args, self._server_address)
+
+    async def run_headless(self, args: argparse.Namespace):
+        """Run headless server in a separate thread."""
+        args.api_server_count = 0
+
+        def run_headless_wrapper():
+            with SuppressSignalInThread():
+                run_headless(args)
+
+        def on_run_headless_done(future: asyncio.Future):
+            try:
+                exc = future.exception()
+                if exc:
+                    logger.exception(f"run_headless failed with exception: {exc}")
+                else:
+                    logger.warning("run_headless completed successfully, but it's not expected.")
+            except Exception as e:
+                logger.exception(f"get result from run_headless failed: {e}")
+            finally:
+                os._exit(1)
+
+        self.task = asyncio.create_task(asyncio.to_thread(run_headless_wrapper))
+        self.task.add_done_callback(on_run_headless_done)
+
+    async def generate(
+        self,
+        prompt_ids: list[int],
+        sampling_params: dict[str, Any],
+        request_id: str,
+        image_data: Optional[list[Any]] = None,
+        video_data: Optional[list[Any]] = None,
+        priority: int = 0,
+    ) -> TokenOutput:
+        """Generate sequence with token-in-token-out."""
+        outputs = await self.generate_n(
+            prompt_ids=prompt_ids,
+            sampling_params=sampling_params,
+            request_id=request_id,
+            image_data=image_data,
+            video_data=video_data,
+            priority=priority,
+        )
+        if not outputs:
+            raise RuntimeError("vLLM generate returned no sequences.")
+        return outputs[0]
+
+    async def generate_n(
+        self,
+        prompt_ids: list[int],
+        sampling_params: dict[str, Any],
+        request_id: str,
+        image_data: Optional[list[Any]] = None,
+        video_data: Optional[list[Any]] = None,
+        priority: int = 0,
+    ) -> list[TokenOutput]:
+        """Generate one or more sequences from a shared prefix.
+
+        Passing SamplingParams.n>1 lets vLLM decode multiple future continuations after a
+        single prefill for CRPD candidate blocks or frozen-base futures.
+        """
+        sampling_params = dict(sampling_params)
+        prompt_ids = normalize_token_ids(prompt_ids)
+
+        # Calculate the maximum possible new tokens based on available context space
+        # This serves as a safety upper bound
+        max_possible_tokens = self.config.max_model_len - len(prompt_ids)
+        if max_possible_tokens < 0:
+            raise ValueError(
+                f"Prompt length ({len(prompt_ids)}) exceeds the model's maximum context length "
+                f"({self.config.max_model_len})."
+            )
+
+        # Student blocks use the active adapter; base scoring/futures disable it.
+        use_lora = bool(sampling_params.pop("use_lora", True))
+        strict_context = bool(sampling_params.pop("sps_strict_context", False))
+        require_adapter = bool(sampling_params.pop("crpd_require_adapter", False))
+        future_exponent = sampling_params.pop("power_future_exponent", None)
+        if future_exponent is not None:
+            if use_lora or self.config.logprobs_mode != "processed_logprobs":
+                raise ValueError("Power futures require frozen-base processed proposal log probabilities.")
+            if float(sampling_params.get("temperature", 1.0)) != 1.0 / future_exponent:
+                raise ValueError("Power future temperature must match its exponent.")
+            if not sampling_params.get("logprobs", False):
+                raise ValueError("Power futures require per-token importance weights.")
+            sampling_params["extra_args"] = {"power_future_exponent": float(future_exponent)}
+
+        # Determine max_tokens from sampling_params or use configured response_length as default
+        if "max_tokens" in sampling_params:
+            max_tokens = sampling_params.pop("max_tokens")
+        elif "max_new_tokens" in sampling_params:
+            # support sglang-style 'max_new_tokens' param
+            max_tokens = sampling_params.pop("max_new_tokens")
+        else:
+            # Default to a calculation that considers configured lengths
+            # Cap max_tokens by response_length to ensure tensor alignment,
+            # and by remaining budget to prevent OOM in multi-turn rollouts.
+            max_tokens = min(
+                self.config.response_length, self.config.prompt_length + self.config.response_length - len(prompt_ids)
+            )
+
+        if strict_context and max_tokens > max_possible_tokens:
+            raise ValueError(
+                f"SPS request needs {max_tokens} new tokens but only {max_possible_tokens} fit in "
+                f"the model context (prompt length {len(prompt_ids)}, max_model_len {self.config.max_model_len})."
+            )
+        # Non-SPS requests retain the existing context clamp. SPS uses a fixed horizon and
+        # must fail rather than silently changing the estimator's target.
+        max_tokens = max(0, min(max_tokens, max_possible_tokens))
+
+        assert max_tokens <= max_possible_tokens, (
+            f"max_tokens {max_tokens} exceeds available context space {max_possible_tokens}"
+        )
+        sampling_params["logprobs"] = 0 if sampling_params.pop("logprobs", False) else None
+        sampling_params.setdefault("repetition_penalty", self.config.get("repetition_penalty", 1.0))
+        # AsyncLLM streams CUMULATIVE n-sampling by child request; the last yield
+        # can drop completions. FINAL_ONLY plus index accumulation keeps all n.
+        sampling_params.setdefault("output_kind", RequestOutputKind.FINAL_ONLY)
+        sampling_params = SamplingParams(max_tokens=max_tokens, **sampling_params)
+        prompt_ids = qwen2_5_vl_dedup_image_tokens(prompt_ids, self.model_config.processor)
+        multi_modal_data = {}
+        if image_data is not None:
+            multi_modal_data["image"] = image_data
+        if video_data is not None:
+            multi_modal_data["video"] = video_data
+
+        prompt = TokensPrompt(prompt_token_ids=prompt_ids, multi_modal_data=multi_modal_data)
+
+        lora_request = None
+        if use_lora and require_adapter and not self.lora_as_adapter:
+            raise RuntimeError("CRPD student generation requires an unmerged LoRA adapter.")
+        if use_lora and self.lora_as_adapter:
+            # Make sure we also check that the lora is already loaded in the engine
+            lora_loaded = VLLM_LORA_INT_ID in await self.engine.list_loras()
+            if require_adapter and not lora_loaded:
+                raise RuntimeError("CRPD student adapter is not loaded in vLLM; refusing base fallback.")
+            if lora_loaded:
+                lora_request = LoRARequest(
+                    lora_name=VLLM_LORA_NAME, lora_int_id=VLLM_LORA_INT_ID, lora_path=VLLM_LORA_PATH
+                )
+
+        generator = self.engine.generate(
+            prompt=prompt,
+            sampling_params=sampling_params,
+            request_id=request_id,
+            lora_request=lora_request,
+            priority=priority,
+        )
+
+        # Get final response. Accumulate by completion.index because AsyncLLM may
+        # emit a subset of the n sequences in any given RequestOutput.
+        final_res: Optional[RequestOutput] = None
+        completions: dict[int, Any] = {}
+        async for output in generator:
+            final_res = output
+            for completion in output.outputs:
+                completions[int(completion.index)] = completion
+        assert final_res is not None
+        if not completions:
+            raise RuntimeError("vLLM generate_n returned no sequences.")
+
+        extra_fields = {"global_steps": self.global_steps, "decode_logprobs_mode": self.config.logprobs_mode}
+        if future_exponent is not None:
+            extra_fields["decode_logprobs_mode"] = "power_log_weights"
+        if sampling_params.prompt_logprobs is not None:
+            extra_fields["prompt_logprobs_mode"] = "raw_logprobs"
+        extract_prompt_logprobs(
+            output=final_res,
+            num_prompt_logprobs=sampling_params.prompt_logprobs,
+            result_dict=extra_fields,
+        )
+        results = []
+        for completion in (completions[index] for index in sorted(completions)):
+            token_ids = completion.token_ids
+            log_probs = None
+            if sampling_params.logprobs is not None:
+                if completion.logprobs is None:
+                    raise RuntimeError("vLLM generate_n did not return logprobs for a sampled sequence.")
+                log_probs = [logprobs[token_ids[i]].logprob for i, logprobs in enumerate(completion.logprobs)]
+
+            completion_extra_fields = dict(extra_fields)
+            if future_exponent is not None:
+                completion_extra_fields["future_log_power_weights"] = log_probs
+                log_probs = None
+
+            routed_experts = None
+            if self.config.enable_rollout_routing_replay:
+                routed_experts = completion.routed_experts
+
+            finish_reason = completion.finish_reason
+            if finish_reason == "abort":
+                stop_reason = "aborted"
+            elif finish_reason in ("stop", "length"):
+                stop_reason = "completed"
+            else:
+                stop_reason = finish_reason
+
+            num_preempted = completion.num_preempted if hasattr(completion, "num_preempted") else None
+            results.append(
+                TokenOutput(
+                    token_ids=token_ids,
+                    log_probs=log_probs,
+                    routed_experts=routed_experts,
+                    stop_reason=stop_reason,
+                    num_preempted=num_preempted,
+                    extra_fields=completion_extra_fields,
+                )
+            )
+        return results
+
+    async def wake_up(self):
+        if self.node_rank != 0:
+            return
+
+        if self.rollout_mode == RolloutMode.HYBRID:
+            # In hybrid mode, rollout is wake up in `update_weights`
+            raise ValueError(f"wake_up not support rollout_mode {self.rollout_mode}")
+        elif self.rollout_mode == RolloutMode.COLOCATED:
+            # Directly call engine to wake up without sync weights.
+            await self.engine.wake_up(tags=self._get_wake_up_tags())
+            await self.engine.reset_prefix_cache()
+        elif self.rollout_mode == RolloutMode.STANDALONE:
+            logger.info("skip wake_up in standalone mode")
+
+    async def sleep(self):
+        if self.node_rank != 0 or not self.config.free_cache_engine:
+            return
+
+        if self.rollout_mode == RolloutMode.HYBRID:
+            await self._sleep_hybrid()
+        elif self.rollout_mode == RolloutMode.COLOCATED:
+            await self.engine.sleep(level=1)
+        elif self.rollout_mode == RolloutMode.STANDALONE:
+            logger.info("skip sleep in standalone mode")
+
+    async def start_profile(self, **kwargs):
+        if (
+            self.profiler_controller.check_enable()
+            and self.profiler_controller.check_this_rank()
+            and self.profiler_controller.is_discrete_mode()
+        ):
+            await self.engine.start_profile(**kwargs)
+
+    async def stop_profile(self):
+        if (
+            self.profiler_controller.check_enable()
+            and self.profiler_controller.check_this_rank()
+            and self.profiler_controller.is_discrete_mode()
+        ):
+            await self.engine.stop_profile()
+
+    async def clear_kv_cache(self):
+        if self.node_rank == 0:
+            await self.engine.reset_prefix_cache()
+
+    async def set_global_steps(self, global_steps: int):
+        """Set the global steps of the model weights."""
+        self.global_steps = global_steps
+
+    async def wait_for_requests_to_drain(self):
+        await self.engine.wait_for_requests_to_drain()
+
+    async def abort_all_requests(self, reset_prefix_cache: bool = True) -> dict[str, Any]:
+        """Abort all ongoing generation requests.
+
+        On vLLM >= 0.12.0, uses AsyncLLM.pause_generation() to abort in-flight
+        requests, drain, and clear caches. The engine remains paused after this
+        call — use resume_generation() to accept new requests (e.g. before
+        validation).
+
+        On vLLM < 0.12.0, manually aborts each request and resets prefix cache.
+
+        Returns:
+            dict[str, Any]: Dictionary containing:
+                - aborted_count: Number of requests aborted
+                - request_ids: List of aborted request IDs
+        """
+        try:
+            if _VLLM_VERSION >= version.parse("0.12.0"):
+                # Snapshot request IDs before pausing for reporting
+                request_ids = list(self.engine.output_processor.request_states.keys())
+
+                # pause_generation with wait_for_inflight_requests=False will:
+                # 1. Set engine to paused state (blocks new generate calls)
+                # 2. Abort all in-flight requests
+                # 3. Wait for requests to drain
+                # 4. Clear prefix and mm caches if clear_cache=True
+                await self.engine.pause_generation(
+                    wait_for_inflight_requests=False,
+                    clear_cache=reset_prefix_cache,
+                )
+            else:
+                # Take an atomic snapshot to avoid race conditions with the vLLM engine thread
+                request_states_snapshot = list(self.engine.output_processor.request_states.items())
+                request_ids = [req_id for req_id, _ in request_states_snapshot]
+
+                if not request_ids:
+                    return {"aborted_count": 0, "request_ids": []}
+
+                # For each request, create an abort output and put it to its queue
+                # This allows the generator to receive the aborted result
+                from vllm.v1.engine import FinishReason
+
+                for _, req_state in request_states_snapshot:
+                    request_output = req_state.make_request_output(
+                        [], pooling_output=None, finish_reason=FinishReason.ABORT, stop_reason=None
+                    )
+                    req_state.queue.put(request_output)
+
+                # Abort requests in the output processor and engine core
+                self.engine.output_processor.abort_requests(request_ids)
+                await self.engine.engine_core.abort_requests_async(request_ids)
+
+                # Try to reset prefix cache to ensure clean state
+                if reset_prefix_cache:
+                    await self.clear_kv_cache()
+                    logger.info("Prefix cache reset after abort")
+
+            logger.info(f"Aborted {len(request_ids)} requests: {request_ids}")
+            return {"aborted_count": len(request_ids), "request_ids": request_ids}
+
+        except Exception as e:
+            logger.error(f"Error aborting requests: {e}")
+            return {"aborted_count": 0, "request_ids": [], "error": str(e)}
+
+    async def resume_generation(self):
+        """Resume generation after abort_all_requests (pause_generation).
+
+        Only effective on vLLM >= 0.12.0 where pause_generation is used.
+        No-op on older versions.
+        """
+        if self.node_rank != 0:
+            return
+        if _VLLM_VERSION >= version.parse("0.12.0"):
+            await self.engine.resume_generation()
+
+    async def abort_request(self, request_id: str, reset_prefix_cache: bool = True) -> dict[str, Any]:
+        """Abort a specific generation request.
+
+        Args:
+            request_id: The ID of the request to abort.
+
+        Returns:
+            dict[str, Any]: Dictionary containing abort result.
+        """
+        try:
+            request_states = self.engine.output_processor.request_states
+            req_state = request_states.get(request_id)
+
+            if req_state is None:
+                return {"aborted": False, "error": f"Request {request_id} not found"}
+
+            # Create abort output and put it to the queue
+            from vllm.v1.engine import FinishReason
+
+            request_output = req_state.make_request_output(
+                [], pooling_output=None, finish_reason=FinishReason.ABORT, stop_reason=None
+            )
+            req_state.queue.put(request_output)
+
+            # Abort in output processor and engine core
+            self.engine.output_processor.abort_requests([request_id])
+            await self.engine.engine_core.abort_requests_async([request_id])
+
+            # Try to reset prefix cache to ensure clean state
+            if reset_prefix_cache:
+                await self.clear_kv_cache()
+                logger.info(f"Prefix cache reset after abort request {request_id}")
+
+            logger.info(f"Aborted request: {request_id}")
+            return {"aborted": True, "request_id": request_id}
+
+        except Exception as e:
+            logger.error(f"Error aborting request {request_id}: {e}")
+            return {"aborted": False, "request_id": request_id, "error": str(e)}
+
+    # -----------------------------------------------------------------------
+    # Hook methods for subclass overrides
+    # -----------------------------------------------------------------------
+
+    def _init_config(self, config):
+        """Initialise config. Override when a specific dataclass_type is needed."""
+        return omega_conf_to_dataclass(config)
+
+    def _init_model_config(self, model_config):
+        """Initialise model_config. Override when a specific dataclass_type is needed."""
+        return omega_conf_to_dataclass(model_config, dataclass_type=HFModelConfig)
+
+    def _validate_configs(self) -> None:
+        """Validate config/model_config after initialisation."""
+        max_position_embeddings = get_max_position_embeddings(self.model_config.hf_config)
+        if self.config.max_model_len is None:
+            self.config.max_model_len = max_position_embeddings
+        else:
+            if self.config.max_model_len > max_position_embeddings:
+                raise ValueError(
+                    f"max_model_len ({self.config.max_model_len}) should be less than or equal to "
+                    f"max_position_embeddings ({max_position_embeddings})"
+                )
+
+    def _post_init(self, cuda_visible_devices: str) -> None:
+        """Called at the end of __init__. Default logs server metadata."""
+        logger.info(
+            f"{self.__class__.__name__}, replica_rank: {self.replica_rank}, node_rank: {self.node_rank}, "
+            f"{get_visible_devices_keyword()}: {cuda_visible_devices}, "
+            f"master_address: {self._master_address}, master_port: {self._master_port}, "
+            f"data_parallel_rpc_port: {self._dp_rpc_port}, data_parallel_master_port: {self._dp_master_port}"
+        )
+
+    def _get_engine_kwargs_key(self) -> str:
+        """Return the key under config.engine_kwargs for this engine (e.g. 'vllm')."""
+        return "vllm"
+
+    def _preprocess_engine_kwargs(self, engine_kwargs: dict) -> None:
+        """Mutate engine_kwargs in-place before the CLI args dict is built. No-op by default."""
+        pass
+
+    def _get_override_generation_config(self) -> dict:
+        """Return the override_generation_config dict."""
+        # Override default generation config from hugging face model config,
+        # user can still override them by passing kwargs in each request.
+        return dict(
+            temperature=self.config.temperature,
+            top_k=self.config.top_k,
+            top_p=self.config.top_p,
+            repetition_penalty=1.0,
+            max_new_tokens=self.config.response_length,
+        )
+
+    def _apply_quantization(self) -> tuple[Optional[str], dict]:
+        """Process quantization config. Returns (quantization_str, hf_overrides)."""
+        quantization = self.config.quantization
+        hf_overrides = {}
+
+        if is_torch_npu_available(check_device=False):
+            from verl.utils.vllm.npu_vllm_patch import check_vllm_ascend_before_server_launch
+
+            check_vllm_ascend_before_server_launch()
+
+        # Handle QAT (Quantization-Aware Training) configuration
+        qat_config_dict = getattr(self.config, "qat", {}) or {}
+        if qat_config_dict.get("enable", False):
+            from verl.utils.qat import QATConfig, load_quantization_config
+
+            qat_config = QATConfig(**qat_config_dict)
+            quantization_config_dict = load_quantization_config(qat_config)
+            quant_method = quantization_config_dict.get("quant_method", None)
+
+            if quant_method == "modelopt":
+                from verl.utils.modelopt import apply_modelopt_nvfp4_patches
+
+                apply_modelopt_nvfp4_patches()
+                quantization = "modelopt"
+            elif quant_method == "compressed-tensors":
+                from verl.utils.qat import apply_qat_patches
+
+                apply_qat_patches()
+                quantization = "compressed-tensors"
+            else:
+                raise ValueError(f"Unsupported quant_method: {quant_method}")
+
+            logger.info(f"QAT quantization config injected (quant_method={quant_method})")
+            hf_overrides["quantization_config"] = quantization_config_dict
+        elif quantization is not None:
+            # Handle other quantization methods (fp8, torchao)
+            _SUPPORTED_QUANTIZATION = ["fp8", "torchao", "ascend"]
+            if quantization not in _SUPPORTED_QUANTIZATION:
+                raise ValueError(f"Currently only support {_SUPPORTED_QUANTIZATION} quantization, got: {quantization}")
+
+            if quantization == "fp8":
+                # Ignore MoE router layers for FP8 quantization
+                all_mlp_gate_layers = []
+                for layer in range(self.model_config.hf_config.num_hidden_layers):
+                    all_mlp_gate_layers.append(f"model.layers.{layer}.mlp.gate")
+
+                FP8_BLOCK_QUANT_KWARGS = {
+                    "activation_scheme": "dynamic",
+                    "fmt": "e4m3",
+                    "quant_method": "fp8",
+                    "weight_block_size": [128, 128],
+                    "ignored_layers": all_mlp_gate_layers,
+                }
+                hf_overrides["quantization_config"] = dict(FP8_BLOCK_QUANT_KWARGS)
+                # Apply vllm fp8 patches
+                # Will remove the patch after vllm support on-the-fly quant for rollout natively.
+                apply_vllm_fp8_patches()
+                # for subprocesses patching
+                os.environ["VERL_VLLM_FP8_QUANT_ENABLED"] = "1"
+
+        if quantization is not None and self.config.quantization_config_file is not None:
+            hf_overrides["quantization_config_file"] = self.config.quantization_config_file
+
+        return quantization, hf_overrides
+
+    def _get_worker_extension_cls(self) -> str:
+        """Return the fully-qualified colocate worker extension class name."""
+        return "verl.workers.rollout.vllm_rollout.utils.vLLMColocateWorkerExtension"
+
+    def _get_cli_modules(self) -> list:
+        """Return the list of CLI command modules used for argument parsing."""
+        return [vllm.entrypoints.cli.serve]
+
+    def _get_cli_description(self) -> str:
+        """Return the description string for the CLI argument parser."""
+        return "vLLM CLI"
+
+    def _get_wake_up_tags(self) -> list[str]:
+        """Return the tags passed to engine.wake_up(). Default includes kv_cache."""
+        return ["kv_cache", "weights"]
+
+    async def _sleep_hybrid(self):
+        """HYBRID sleep: lora adapters only need level=1; full weights need level=2."""
+        # Don't use engine.sleep(level=2) here
+        # lora only update adapter weights, so set sleep level to 1
+        if self.lora_as_adapter:
+            sleep_level = 1
+        else:
+            sleep_level = 2
+        await self.engine.collective_rpc("sleep", kwargs={"level": sleep_level})
+        if _VLLM_VERSION >= version.parse("0.17.0"):
+            await self.engine.reset_encoder_cache()
+
+
+class vLLMReplica(RolloutReplica):
+    def __init__(
+        self,
+        replica_rank: int,
+        config: RolloutConfig,
+        model_config: HFModelConfig,
+        gpus_per_node: int = 8,
+        is_reward_model: bool = False,
+        is_teacher_model: bool = False,
+    ):
+        super().__init__(replica_rank, config, model_config, gpus_per_node, is_reward_model, is_teacher_model)
+        self.server_class = ray.remote(vLLMHttpServer)
+
+    async def launch_servers(self):
+        """Launch http server in each node."""
+        assert len(self.workers) == self.world_size, (
+            f"worker number {len(self.workers)} not equal to world size {self.world_size}"
+        )
+
+        self._validate_launch_requirements()
+
+        # get (node_id, CUDA_VISIBLE_DEVICES) of all workers
+        worker_infos = await asyncio.gather(
+            *[
+                worker.__ray_call__.remote(
+                    lambda self: (
+                        ray.get_runtime_context().get_node_id(),
+                        ray.get_runtime_context().get_accelerator_ids()[get_resource_name()][0],
+                    )
+                )
+                for worker in self.workers
+            ]
+        )
+        worker_cuda_visible_devices = [worker_info[1] for worker_info in worker_infos]
+        worker_node_ids = [worker_info[0] for worker_info in worker_infos]
+
+        # create server actor in each node with node affinity and cuda visible devices
+        nnodes, gpus_per_replica_node = self.nnodes, self.gpus_per_replica_node
+        for node_rank in range(nnodes):
+            workers = self.workers[node_rank * gpus_per_replica_node : (node_rank + 1) * gpus_per_replica_node]
+            node_cuda_visible_devices = ",".join(
+                worker_cuda_visible_devices[node_rank * gpus_per_replica_node : (node_rank + 1) * gpus_per_replica_node]
+            )
+            node_id = worker_node_ids[node_rank * gpus_per_replica_node]
+            prefix = self._get_server_name_prefix()
+            if self.is_reward_model:
+                name = f"{prefix}server_reward_{self.replica_rank}_{node_rank}"
+            elif self.is_teacher_model:
+                name = f"{prefix}server_teacher_{self.replica_rank}_{node_rank}"
+            else:
+                name = f"{prefix}server_{self.replica_rank}_{node_rank}"
+            server = self.server_class.options(
+                scheduling_strategy=ray.util.scheduling_strategies.NodeAffinitySchedulingStrategy(
+                    node_id=node_id,
+                    soft=False,
+                ),
+                runtime_env={
+                    "env_vars": {
+                        "RAY_EXPERIMENTAL_NOSET_CUDA_VISIBLE_DEVICES": "1",
+                        "RAY_EXPERIMENTAL_NOSET_ASCEND_RT_VISIBLE_DEVICES": "1",
+                        # To prevent hanging or crash during synchronization of weights between actor and rollout
+                        # in disaggregated mode. See:
+                        # https://docs.vllm.ai/en/latest/usage/troubleshooting.html?h=nccl_cumem_enable#known-issues
+                        # https://github.com/vllm-project/vllm/blob/c6b0a7d3ba03ca414be1174e9bd86a97191b7090/vllm/worker/worker_base.py#L445
+                        "NCCL_CUMEM_ENABLE": "0",
+                    }
+                },
+                name=name,
+                max_concurrency=self.max_concurrency,
+            ).remote(
+                config=self.config,
+                model_config=self.model_config,
+                rollout_mode=self.rollout_mode,
+                workers=workers,
+                replica_rank=self.replica_rank,
+                node_rank=node_rank,
+                gpus_per_node=gpus_per_replica_node,
+                nnodes=nnodes,
+                cuda_visible_devices=node_cuda_visible_devices,
+            )
+            self.servers.append(server)
+
+        # launch http server in each node
+        master_address, master_port, dp_rpc_port = await self.servers[0].get_master_address.remote()
+        await asyncio.gather(
+            *[
+                server.launch_server.remote(
+                    master_address=master_address, master_port=master_port, dp_rpc_port=dp_rpc_port
+                )
+                for server in self.servers
+            ]
+        )
+
+        # get http server address from first server
+        server_address, server_port = await self.servers[0].get_server_address.remote()
+        self._server_handle = self.servers[0]
+        self._server_address = (
+            f"[{server_address}]:{server_port}"
+            if is_valid_ipv6_address(server_address)
+            else f"{server_address}:{server_port}"
+        )
+
+    async def sleep(self):
+        """Sleep each rollout server."""
+        # Drain DP engines for safe sleep.
+        await self.servers[0].wait_for_requests_to_drain.remote()
+        await asyncio.gather(*[server.sleep.remote() for server in self.servers])
+
+    async def abort_all_requests(self) -> dict[str, Any]:
+        """Abort all ongoing generation requests across all servers.
+
+        Returns:
+            dict[str, Any]: Combined abort results from all servers.
+        """
+        results = await asyncio.gather(*[server.abort_all_requests.remote() for server in self.servers])
+
+        total_aborted = sum(r.get("aborted_count", 0) for r in results)
+        all_request_ids = []
+        for r in results:
+            all_request_ids.extend(r.get("request_ids", []))
+
+        return {
+            "aborted_count": total_aborted,
+            "request_ids": all_request_ids,
+            "server_results": results,
+        }
+
+    async def resume_generation(self):
+        """Resume generation on all servers after abort_all_requests."""
+        await asyncio.gather(*[server.resume_generation.remote() for server in self.servers])
+
+    async def abort_request(self, request_id: str) -> dict[str, Any]:
+        """Abort a specific request. Tries all servers since we don't know which one has it.
+
+        Args:
+            request_id: The ID of the request to abort.
+
+        Returns:
+            dict[str, Any]: Abort result.
+        """
+        # TODO(petersh6): we should only abort on the server that has the request.
+        results = await asyncio.gather(*[server.abort_request.remote(request_id) for server in self.servers])
+
+        for r in results:
+            if r.get("aborted", False):
+                return r
+
+        return {"aborted": False, "request_id": request_id, "error": "Request not found on any server"}
+
+    # -----------------------------------------------------------------------
+    # Hook methods for subclass overrides
+    # -----------------------------------------------------------------------
+
+    def _validate_launch_requirements(self) -> None:
+        """Validate requirements before launching. Override in subclasses."""
+        # NOTE: We always use MP Executor backend whether it's single-node or multi-node.
+        # For multi-node without DP (e.g TP=16), need vllm>=0.11.1, https://github.com/vllm-project/vllm/pull/23691
+        if self.config.data_parallel_size == 1 and self.nnodes > 1:
+            assert _VLLM_VERSION >= version.parse("0.11.1"), (
+                "For multi-node MP Executor, either (1) set data_parallel_size > 1 or (2) upgrade vLLM to >= 0.11.1"
+            )
+
+    def _get_server_name_prefix(self) -> str:
+        """Return the Ray actor name prefix (e.g. 'vllm_' or 'vllm_omni_')."""
+        return "vllm_"