[Core] Graduate MiniCPM-o 4.5 and PersonaPlex full-duplex serving out of experimental (#6196)

Signed-off-by: chickeyton <ngton2014@gmail.com>
Signed-off-by: Gao Han <hgaoaf@connect.ust.hk>
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
Co-authored-by: Gao Han <hgaoaf@connect.ust.hk>

tests/entrypoints/duplex/test_duplex_audio.py

@@ -0,0 +1,54 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import base64
+
+import numpy as np
+import pytest
+
+from vllm_omni.entrypoints.duplex.audio import convert_input_audio_with_rate
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_pcm16_input_conversion_is_pure_and_reports_target_rate():
+    pcm16 = np.array([-32768, 0, 32767], dtype="<i2").tobytes()
+    encoded = base64.b64encode(pcm16).decode("ascii")
+
+    converted, fmt, sample_rate = convert_input_audio_with_rate(
+        encoded,
+        "pcm16",
+        sample_rate_hz=16_000,
+    )
+
+    assert encoded == base64.b64encode(pcm16).decode("ascii")
+    assert fmt == "pcm_f32le"
+    assert sample_rate == 16_000
+    samples = np.frombuffer(base64.b64decode(converted), dtype="<f4")
+    assert np.allclose(samples, [-1.0, 0.0, 32767 / 32768])
+
+
+@pytest.mark.parametrize("sample_rate_hz", [8_000, 192_000])
+def test_pcm16_input_conversion_accepts_supported_sample_rate_boundaries(sample_rate_hz: int):
+    encoded = base64.b64encode(np.zeros(8, dtype="<i2").tobytes()).decode("ascii")
+
+    _, fmt, converted_rate = convert_input_audio_with_rate(
+        encoded,
+        "pcm16",
+        sample_rate_hz=sample_rate_hz,
+    )
+
+    assert fmt == "pcm_f32le"
+    assert converted_rate == 16_000
+
+
+@pytest.mark.parametrize("sample_rate_hz", [7_999, 192_001, 10**1000])
+def test_pcm16_input_conversion_rejects_sample_rates_outside_supported_range(sample_rate_hz: int):
+    encoded = base64.b64encode(np.zeros(8, dtype="<i2").tobytes()).decode("ascii")
+
+    with pytest.raises(ValueError, match="sample_rate_hz"):
+        convert_input_audio_with_rate(
+            encoded,
+            "pcm16",
+            sample_rate_hz=sample_rate_hz,
+        )

tests/entrypoints/duplex/test_runtime_adapter_boundary.py

@@ -0,0 +1,146 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from vllm_omni.entrypoints.duplex.runtime_adapter import (
+    validate_serving_runtime_adapter,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+@pytest.mark.parametrize(
+    "module_name",
+    [
+        "vllm_omni.entrypoints.duplex.session_runner",
+        "vllm_omni.entrypoints.duplex.runtime_bridge",
+        "vllm_omni.entrypoints.duplex.serving",
+    ],
+)
+def test_generic_openai_runtime_import_does_not_load_model_adapters(module_name: str) -> None:
+    repo_root = Path(__file__).resolve().parents[3]
+    script = f"""
+import sys
+
+import {module_name}
+
+model_duplex_prefixes = (
+    "vllm_omni.model_executor.models.minicpmo_4_5.duplex",
+    "vllm_omni.model_executor.models.nemotron_voicechat.duplex",
+    "vllm_omni.model_executor.models.personaplex.duplex",
+)
+loaded = sorted(
+    name
+    for name in sys.modules
+    if any(
+        name == prefix or name.startswith(prefix + ".")
+        for prefix in model_duplex_prefixes
+    )
+)
+if loaded:
+    raise SystemExit("generic OpenAI runtime loaded model duplex modules: " + ", ".join(loaded))
+"""
+
+    result = subprocess.run(
+        [sys.executable, "-c", script],
+        cwd=repo_root,
+        capture_output=True,
+        text=True,
+        timeout=60,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stderr
+
+
+def test_generic_handler_requires_explicit_serving_runtime_adapter() -> None:
+    repo_root = Path(__file__).resolve().parents[3]
+    script = """
+from types import SimpleNamespace
+
+from vllm_omni.entrypoints.duplex.serving import OmniDuplexSessionHandler
+
+chat_service = SimpleNamespace(engine_client=SimpleNamespace())
+try:
+    OmniDuplexSessionHandler(chat_service=chat_service)
+except ValueError as exc:
+    if "serving runtime adapter" not in str(exc).lower():
+        raise
+else:
+    raise SystemExit("generic handler silently selected a model serving adapter")
+"""
+
+    result = subprocess.run(
+        [sys.executable, "-c", script],
+        cwd=repo_root,
+        capture_output=True,
+        text=True,
+        timeout=60,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stderr
+
+
+def _valid_runtime_adapter() -> SimpleNamespace:
+    data_plane = SimpleNamespace(
+        begin_request=lambda request_id: None,
+        is_terminal=lambda request_id: False,
+        mark_terminal=lambda request_id: None,
+        close_stream=lambda request_id: None,
+        close_session=lambda session_id, **kwargs: None,
+        project=lambda result, **kwargs: (),
+    )
+    return SimpleNamespace(
+        adapter_id="test-adapter",
+        session_states={},
+        data_plane=data_plane,
+        clean_response_done_prefix="clean",
+        interrupted_tts_prefix="interrupted",
+        private_runtime_config_keys=frozenset({"private_key"}),
+        create_session_state=lambda: object(),
+        session_state=lambda session_id: object(),
+        remove_session_state=lambda session_id: None,
+        is_enabled=lambda config: True,
+        capabilities=lambda **kwargs: object(),
+        validate_client_extra_body=lambda extra_body: None,
+        prepare_runtime_config=lambda config, **kwargs: {},
+        runtime_config_for_update=lambda config, current: {},
+        data_plane_context=lambda **kwargs: object(),
+    )
+
+
+@pytest.mark.parametrize(
+    ("attribute", "invalid_value"),
+    [
+        ("session_states", None),
+        ("clean_response_done_prefix", None),
+        ("interrupted_tts_prefix", None),
+        ("private_runtime_config_keys", {"private_key"}),
+    ],
+)
+def test_runtime_adapter_validator_rejects_invalid_protocol_attributes(
+    attribute: str,
+    invalid_value: object,
+) -> None:
+    adapter = _valid_runtime_adapter()
+    setattr(adapter, attribute, invalid_value)
+
+    with pytest.raises(TypeError, match=attribute):
+        validate_serving_runtime_adapter(adapter)
+
+
+def test_runtime_adapter_validator_rejects_incomplete_data_plane() -> None:
+    adapter = _valid_runtime_adapter()
+    adapter.data_plane.close_session = None
+
+    with pytest.raises(TypeError, match="data_plane.*close_session"):
+        validate_serving_runtime_adapter(adapter)

tests/entrypoints/duplex/test_runtime_control_redaction.py

@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+"""Regression tests for duplex ``runtime_control`` payload redaction.
+
+The redacted result is emitted on the WebSocket (for example
+``session.created.runtime_control``), so it must always survive
+``json.dumps``. Control results carry typed values straight from the engine --
+``fence`` and ``accepted_fence`` are ``DuplexFence`` instances added by
+``DuplexControlClient.execute`` -- which previously reached
+``WebSocket.send_json`` unconverted and killed the session at handshake.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from enum import Enum
+
+import pytest
+
+from vllm_omni.engine.duplex.messages import DuplexFence
+from vllm_omni.entrypoints.duplex.runtime_bridge import NativeRuntimeBridgeMixin
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+_redact = NativeRuntimeBridgeMixin._redact_runtime_control_result
+
+
+def _control_result() -> dict[str, object]:
+    """The shape ``DuplexControlClient.execute`` returns for an open."""
+    return {
+        "ok": True,
+        "operation": "open",
+        "session_id": "sess-1",
+        "fence": DuplexFence("sess-1", epoch=0, turn_id=0, response_seq=0, incarnation=0),
+        "accepted_fence": DuplexFence("sess-1", epoch=1, turn_id=2, response_seq=3, incarnation=4),
+        "stage_results": [{"stage_id": -1, "replica_id": -1, "result": {"supported": True}}],
+    }
+
+
+def test_redacted_control_result_is_json_serializable() -> None:
+    """The whole payload must serialize the way send_json does."""
+    redacted = _redact(_control_result())
+    # Must not raise.
+    json.dumps({"type": "session.created", "runtime_control": redacted})
+
+
+def test_fences_are_converted_to_plain_dicts() -> None:
+    redacted = _redact(_control_result())
+    assert redacted["fence"] == {
+        "session_id": "sess-1",
+        "epoch": 0,
+        "turn_id": 0,
+        "response_seq": 0,
+        "incarnation": 0,
+    }
+    # Field values are preserved, not just the type.
+    assert redacted["accepted_fence"]["epoch"] == 1
+    assert redacted["accepted_fence"]["turn_id"] == 2
+    assert redacted["accepted_fence"]["response_seq"] == 3
+    assert redacted["accepted_fence"]["incarnation"] == 4
+
+
+def test_nested_dataclasses_are_converted() -> None:
+    """Fences can appear inside stage results, not only at the top level."""
+    redacted = _redact(
+        {
+            "stage_results": [
+                {"stage_id": 0, "result": {"fence": DuplexFence("sess-2", epoch=7)}},
+            ]
+        }
+    )
+    json.dumps(redacted)
+    assert redacted["stage_results"][0]["result"]["fence"]["epoch"] == 7
+
+
+def test_enums_are_reduced_to_values() -> None:
+    class _Mode(str, Enum):
+        APPEND = "append_audio_chunk"
+
+    redacted = _redact({"mode": _Mode.APPEND})
+    json.dumps(redacted)
+    assert redacted["mode"] == "append_audio_chunk"
+
+
+def test_redaction_still_drops_heavy_payload_keys() -> None:
+    """The pre-existing contract must be preserved."""
+    redacted = _redact(
+        {
+            "ok": True,
+            "stage_handoff": object(),
+            "tts_handoff": object(),
+            "omni_payload": object(),
+            "tts_hidden_states": object(),
+            "tts_token_ids": object(),
+            "traceback": "long trace",
+        }
+    )
+    assert redacted == {"ok": True}
+
+
+def test_plain_values_pass_through_unchanged() -> None:
+    payload = {"ok": True, "count": 3, "name": "x", "missing": None, "items": [1, "two"]}
+    assert _redact(payload) == payload
+
+
+def test_dataclass_types_are_not_treated_as_instances() -> None:
+    """A class object is not a dataclass instance and must not be asdict'd."""
+
+    @dataclass
+    class _Shape:
+        x: int = 1
+
+    assert _redact(_Shape) is _Shape

tests/entrypoints/duplex/test_websocket_actor.py

@@ -0,0 +1,145 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+import asyncio
+
+import pytest
+
+from vllm_omni.entrypoints.duplex.websocket import (
+    DuplexWebSocketActor,
+    normalize_duplex_input_event,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class FakeWebSocket:
+    def __init__(self) -> None:
+        self.sent: list[dict[str, object]] = []
+
+    async def send_json(self, payload: dict[str, object]) -> None:
+        self.sent.append(dict(payload))
+
+
+@pytest.mark.parametrize(
+    ("event", "expected"),
+    [
+        ({"type": "signal_turn", "event": "barge_in"}, {"type": "turn.signal", "event": "barge_in"}),
+        ({"type": "close_session"}, {"type": "session.close"}),
+        ({"type": "audio.playback_ack", "played_ms": 1}, {"type": "playback.ack", "played_ms": 1}),
+        ({"type": "input_text.append", "text": "a"}, {"type": "input.text.append", "text": "a"}),
+        ({"type": "push_text", "text": "b"}, {"type": "input.text.append", "text": "b"}),
+        (
+            {"type": "input.audio.append", "audio": "wav"},
+            {"type": "input_audio_buffer.append", "audio": "wav", "format": "wav"},
+        ),
+        (
+            {"type": "push_chunk", "audio": "wav", "format": "pcm_f32le"},
+            {"type": "input_audio_buffer.append", "audio": "wav", "format": "pcm_f32le"},
+        ),
+    ],
+)
+def test_input_aliases_normalize_once_at_mailbox_boundary(event, expected):
+    assert normalize_duplex_input_event(event) == expected
+
+
+def test_actor_uses_one_fifo_mailbox_for_inbound_events():
+    actor = DuplexWebSocketActor(FakeWebSocket())
+
+    assert isinstance(actor.mailbox, asyncio.Queue)
+    assert not isinstance(actor.mailbox, asyncio.PriorityQueue)
+    assert not hasattr(actor, "control_queue")
+    assert not hasattr(actor, "input_queue")
+    assert not hasattr(actor, "event_queue")
+    assert not hasattr(actor, "lifecycle_state")
+    assert not hasattr(actor, "last_response_id")
+    assert not hasattr(actor, "overlap_speech_ms")
+    assert not hasattr(actor, "transition")
+    assert not hasattr(actor, "output_generation_in_flight")
+    assert not hasattr(actor, "session")
+    assert not hasattr(actor, "runtime_opened")
+    assert not hasattr(actor, "runtime_closed")
+    assert not hasattr(actor, "drain_input_queue")
+    assert not hasattr(actor, "control_events_seen")
+    assert not hasattr(actor, "input_events_seen")
+    assert not hasattr(actor, "cancel_count")
+
+
+@pytest.mark.asyncio
+async def test_control_event_does_not_overtake_earlier_audio_input():
+    actor = DuplexWebSocketActor(FakeWebSocket())
+    await actor.enqueue_event({"type": "input_audio_buffer.append", "audio": "pcm"})
+    await actor.enqueue_event({"type": "response.cancel"})
+
+    assert await actor.next_event() == {"type": "input_audio_buffer.append", "audio": "pcm"}
+    assert await actor.next_event() == {"type": "response.cancel"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("event_type", ["input.cancel", "session.close", "close_session"])
+async def test_terminal_control_preserves_wire_order(event_type: str):
+    actor = DuplexWebSocketActor(FakeWebSocket())
+    await actor.enqueue_event({"type": "input_audio_buffer.append", "audio": "pcm"})
+    await actor.enqueue_event({"type": event_type})
+
+    assert await actor.next_event() == {"type": "input_audio_buffer.append", "audio": "pcm"}
+    assert await actor.next_event() == {"type": event_type}
+
+
+@pytest.mark.asyncio
+async def test_mailbox_delivers_every_enqueued_event_exactly_once():
+    actor = DuplexWebSocketActor(FakeWebSocket())
+    events = [
+        {"type": "input_audio_buffer.append", "audio": str(index)}
+        if index % 2
+        else {"type": "response.created", "response_id": f"resp-{index}"}
+        for index in range(20)
+    ]
+
+    await asyncio.gather(*(actor.enqueue_event(dict(event)) for event in events))
+    received = [await actor.next_event() for _ in events]
+
+    assert sorted(received, key=repr) == sorted(events, key=repr)
+
+
+@pytest.mark.asyncio
+async def test_writer_is_single_owner_of_websocket_send():
+    websocket = FakeWebSocket()
+    actor = DuplexWebSocketActor(websocket)
+    writer = asyncio.create_task(actor.writer_loop())
+
+    await actor.send_json({"type": "one"})
+    await actor.send_json({"type": "two"})
+    await actor.close_writer()
+    await writer
+
+    assert websocket.sent == [{"type": "one"}, {"type": "two"}]
+
+
+@pytest.mark.asyncio
+async def test_stale_fence_payload_is_dropped_before_websocket_send():
+    websocket = FakeWebSocket()
+    actor = DuplexWebSocketActor(websocket, current_epoch=lambda: 2)
+    writer = asyncio.create_task(actor.writer_loop())
+
+    await actor.send_json({"type": "response.audio.delta", "epoch": 1})
+    await actor.send_json({"type": "response.audio.delta", "epoch": 2})
+    await actor.close_writer()
+    await writer
+
+    assert websocket.sent == [{"type": "response.audio.delta", "epoch": 2}]
+    assert actor.stale_output_dropped == 1
+
+
+@pytest.mark.asyncio
+async def test_writer_does_not_revoke_accepted_terminal_after_close_starts():
+    websocket = FakeWebSocket()
+    actor = DuplexWebSocketActor(websocket, current_epoch=lambda: 1)
+    await actor.send_json({"type": "response.done", "epoch": 1, "response_id": "resp-1"})
+    actor.closing = True
+    await actor.close_writer()
+
+    await actor.writer_loop()
+
+    assert websocket.sent == [{"type": "response.done", "epoch": 1, "response_id": "resp-1"}]
+    assert actor.stale_output_dropped == 0