[Model] Add native full-duplex Nemotron VoiceChat serving (#6089)

Signed-off-by: Sysy <1370724210@qq.com>
Signed-off-by: sy03 <137072421@qq.com>
Co-authored-by: sy03 <137072421@qq.com>

tests/e2e/features/fullduplex/nemotron_voicechat/test_data_plane.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+
+from vllm_omni.experimental.fullduplex.engine.duplex_runtime import duplex_resource_request_id
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+from vllm_omni.experimental.fullduplex.nemotron_voicechat.data_plane import (
+    NemotronVoiceChatDataPlaneContext,
+    NemotronVoiceChatDataPlaneSession,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+_RUNTIME = {
+    "nvc_text_bos_id": 0,
+    "nvc_text_eos_id": 1,
+    "nvc_text_pad_id": 12,
+    "nvc_function_sotc_id": 20,
+    "nvc_function_eotc_id": 21,
+    "nvc_tokenizer_ref": "test-tokenizer",
+}
+
+
+def _projector(encode_audio=lambda *_: None) -> NemotronVoiceChatDataPlaneSession:
+    projector = NemotronVoiceChatDataPlaneSession(encode_audio)
+    projector.configure_runtime(_RUNTIME, tokenizer=SimpleNamespace(decode=lambda *_args, **_kwargs: "text"))
+    return projector
+
+
+def _stage0_output(request_id: str = "req-0", *, text_token: int = 12, function_token: int | None = None) -> object:
+    metadata: dict[str, object] = {"nvc_text_token_ids": [text_token]}
+    if function_token is not None:
+        metadata["nvc_function_token"] = [function_token]
+    completion = SimpleNamespace(multimodal_output=metadata)
+    return SimpleNamespace(
+        stage_id=0,
+        request_output=SimpleNamespace(request_id=request_id, outputs=[completion]),
+    )
+
+
+def test_function_channel_projects_completed_call_without_ending_speech() -> None:
+    projector = _projector()
+    projector._decode = lambda token_ids: (
+        '[{"name":"weather","arguments":{"city":"Shanghai"}}]' if token_ids == [99] else ""
+    )
+    context = NemotronVoiceChatDataPlaneContext(epoch=0)
+
+    events = []
+    for function_token in (20, 99, 21):
+        events.extend(projector.project_output(_stage0_output(function_token=function_token), context=context))
+
+    listen = [event for event in events if event.get("is_listen") is True]
+    function = [event for event in events if event.get("function_call") is True]
+    assert len(listen) == 3
+    assert len(function) == 1
+    assert function[0]["name"] == "weather"
+    assert function[0]["arguments"] == '{"city":"Shanghai"}'
+
+    projector._decode = lambda _token_ids: "not-json"
+    bad_events = []
+    for function_token in (20, 98, 21):
+        bad_events.extend(projector.project_output(_stage0_output(function_token=function_token)))
+    assert any(event.get("error_code") == "nemotron_function_call_parse_error" for event in bad_events)
+
+
+def test_new_epoch_request_does_not_inherit_partial_function_or_frame_state() -> None:
+    projector = _projector(lambda *_: "audio")
+    old_request = duplex_resource_request_id(DuplexFence("sid", epoch=1), "stage0")
+    new_request = duplex_resource_request_id(DuplexFence("sid", epoch=2), "stage0")
+
+    projector.begin_request(old_request)
+    list(projector.project_output(_stage0_output(old_request, text_token=42, function_token=20)))
+    projector.begin_request(new_request)
+
+    # EOTC in the new epoch must not close the old epoch's partial function.
+    new_events = list(projector.project_output(_stage0_output(new_request, text_token=1, function_token=21)))
+    assert not [event for event in new_events if event.get("function_call") is True]
+    assert not [event for event in new_events if event.get("end_of_turn") is True]
+
+    audio = SimpleNamespace(
+        stage_id=2,
+        request_output=SimpleNamespace(
+            request_id=new_request,
+            outputs=[
+                SimpleNamespace(multimodal_output={"model_outputs": [np.ones(1764, dtype=np.float32)], "sr": [22050]})
+            ],
+        ),
+    )
+    audio_events = list(projector.project_output(audio))
+    assert sum(event.get("end_of_turn") is True for event in audio_events) == 1

tests/e2e/features/fullduplex/nemotron_voicechat/test_input.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import base64
+
+import numpy as np
+import pytest
+
+from vllm_omni.experimental.fullduplex.nemotron_voicechat.input import (
+    NemotronVoiceChatPcmAppendBuffer,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _payload(samples: np.ndarray, *, sample_rate_hz: int = 16000, fmt: str = "pcm_f32le") -> dict[str, object]:
+    return {
+        "type": "audio",
+        "audio": base64.b64encode(np.asarray(samples, dtype=np.float32).tobytes()).decode("ascii"),
+        "format": fmt,
+        "sample_rate_hz": sample_rate_hz,
+    }
+
+
+def _append(buffer, samples, operation_id):
+    return buffer.prepare_append(
+        _payload(np.asarray(samples, dtype=np.float32)),
+        operation_id=operation_id,
+        chunk_period_ms=80,
+        allow_emit=True,
+    )
+
+
+def test_irregular_browser_packets_emit_exact_ordered_80ms_frame() -> None:
+    buffer = NemotronVoiceChatPcmAppendBuffer()
+    assert _append(buffer, np.arange(1000), "packet-1") is None
+
+    reservation = _append(buffer, np.arange(1000, 1280), "packet-2")
+
+    assert reservation is not None
+    assert reservation.operation_id == "packet-2"
+    decoded = np.frombuffer(base64.b64decode(reservation.payload["audio"]), dtype=np.float32)
+    np.testing.assert_array_equal(decoded, np.arange(1280, dtype=np.float32))
+    assert buffer.pending_byte_count == 0
+
+
+def test_append_rejects_invalid_frame_contract() -> None:
+    cases = (
+        (1281, 16000, "pcm_f32le", 0.0, "at most 1280"),
+        (1, 8000, "pcm_f32le", 0.0, "sample_rate_hz"),
+        (1, 16000, "audio/pcm", 0.0, "format"),
+        (1, 16000, "pcm_f32le", np.nan, "finite"),
+    )
+    for samples, sample_rate_hz, fmt, value, message in cases:
+        with pytest.raises(ValueError, match=message):
+            NemotronVoiceChatPcmAppendBuffer().prepare_append(
+                _payload(np.full(samples, value, dtype=np.float32), sample_rate_hz=sample_rate_hz, fmt=fmt),
+                operation_id="invalid",
+                chunk_period_ms=80,
+                allow_emit=True,
+            )
+
+
+def test_terminal_commit_rejects_more_than_one_frame_tail() -> None:
+    buffer = NemotronVoiceChatPcmAppendBuffer()
+    for index, samples in enumerate((1000, 281)):
+        buffer.prepare_append(
+            _payload(np.zeros(samples, dtype=np.float32)),
+            operation_id=f"tail-{index}",
+            chunk_period_ms=80,
+            allow_emit=False,
+        )
+    with pytest.raises(ValueError, match="more than one 80 ms frame"):
+        buffer.prepare_commit(operation_id="commit", chunk_period_ms=80)

tests/e2e/features/fullduplex/nemotron_voicechat/test_runtime_contract.py

@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import base64
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+from vllm.sampling_params import SamplingParams
+
+from vllm_omni.experimental.fullduplex.engine.contracts import DuplexInputMode
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+from vllm_omni.experimental.fullduplex.nemotron_voicechat.runtime import (
+    NemotronVoiceChatDuplexRuntimeExtension,
+)
+from vllm_omni.experimental.fullduplex.nemotron_voicechat.serving_adapter import (
+    NemotronVoiceChatServingRuntimeAdapter,
+    _render_tool_response,
+)
+from vllm_omni.model_executor.models.nemotron_voicechat.nemotron_voicechat_thinker import (
+    NemotronVoiceChatThinkerForConditionalGeneration,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def _frame() -> dict[str, object]:
+    raw = np.zeros(1280, dtype=np.float32).tobytes()
+    return {
+        "type": "audio",
+        "audio": base64.b64encode(raw).decode("ascii"),
+        "format": "pcm_f32le",
+        "sample_rate_hz": 16000,
+    }
+
+
+def _plan(extension, *, input_seq: int):
+    return extension.plan_append(
+        request_id="req",
+        fence=DuplexFence("sid", incarnation=2, epoch=3),
+        session_config={},
+        runtime_config={
+            "nvc_prompt_token_ids": [0, 42, 1],
+            "nvc_text_pad_id": 12,
+            "nvc_max_model_len": 8192,
+        },
+        seq=input_seq,
+        turn_seq=input_seq,
+        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+        payload=_frame(),
+        final=False,
+        sampling_params=SamplingParams(),
+    )
+
+
+def test_first_append_prefills_prompt_then_each_append_consumes_one_frame() -> None:
+    extension = NemotronVoiceChatDuplexRuntimeExtension()
+
+    params = extension.configure_sampling_params(
+        runtime_config={}, defaults=(SamplingParams(temperature=0.7, max_tokens=4),)
+    )[0]
+    assert params.temperature == 0.0 and params.max_tokens == 1 and params.top_p == 1.0 and params.top_k == 0
+
+    first = _plan(extension, input_seq=1)
+    later = _plan(extension, input_seq=2)
+
+    assert first.prompt["prompt_token_ids"] == [0, 42, 1, 12]
+    assert later.prompt["prompt_token_ids"] == [12]
+    assert first.prompt["model_intermediate_buffer"]["duplex"]["source_input_seq"] == 1
+    assert later.prompt["model_intermediate_buffer"]["duplex"]["source_input_seq"] == 2
+
+
+def test_append_rejects_stage0_context_overflow() -> None:
+    with pytest.raises(ValueError, match="max_model_len"):
+        _plan(NemotronVoiceChatDuplexRuntimeExtension(), input_seq=8190)
+
+
+def test_function_output_becomes_versioned_nvidia_channel_tokens() -> None:
+    encoded: list[str] = []
+    adapter = NemotronVoiceChatServingRuntimeAdapter(lambda *_: None)
+    adapter._tokenizer = SimpleNamespace(
+        encode=lambda text, **_kwargs: encoded.append(text) or [31, 32, 33],
+    )
+
+    first = adapter.runtime_config_for_function_output(
+        {"type": "function_call_output", "call_id": "call-1", "output": '{"result":20}'},
+        {},
+    )
+    second = adapter.runtime_config_for_function_output(
+        {"type": "function_call_output", "call_id": "call-2", "output": "plain text"},
+        first,
+    )
+
+    assert _render_tool_response('{"result":20}') == '<TOOL_RESPONSE>[{"result":20}]</TOOL_RESPONSE>'
+    assert encoded == [
+        '<TOOL_RESPONSE>[{"result":20}]</TOOL_RESPONSE>',
+        '<TOOL_RESPONSE>["plain text"]</TOOL_RESPONSE>',
+    ]
+    assert first["nvc_function_response_generation"] == 1
+    assert second["nvc_function_response_generation"] == 2
+    assert second["nvc_function_response_token_ids"] == [31, 32, 33]
+    assert second["nvc_function_response_call_id"] == "call-2"
+    assert second["nvc_function_response_batches"] == [
+        {"generation": 1, "call_id": "call-1", "token_ids": [31, 32, 33]},
+        {"generation": 2, "call_id": "call-2", "token_ids": [31, 32, 33]},
+    ]
+
+    session = {"function_response_generation": 0, "forced_function_tokens": []}
+    NemotronVoiceChatThinkerForConditionalGeneration._sync_forced_function_response(session, second)
+
+    assert session["function_response_generation"] == 2
+    assert session["forced_function_token"] == 31
+    assert session["forced_function_tokens"] == [31, 32, 33, 31, 32, 33]