[Refactor][CI] Reorganize test tree, and move slow e2e to weekly (#4951)

Signed-off-by: wangyu <410167048@qq.com>

tests/e2e/features/fullduplex/engine/test_duplex_control_client.py

@@ -0,0 +1,110 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+import pytest
+
+from vllm_omni.experimental.fullduplex.engine.duplex_control_client import (
+    DuplexControlClient,
+    DuplexControlRequestError,
+)
+from vllm_omni.experimental.fullduplex.engine.lease import DuplexLeaseActivity
+from vllm_omni.experimental.fullduplex.engine.messages import (
+    DuplexControlError,
+    DuplexControlResultMessage,
+    DuplexFence,
+    ResumeDuplexSessionMessage,
+    TouchDuplexSessionMessage,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class _Transport:
+    def __init__(self) -> None:
+        self.calls = []
+
+    def execute(self, key, message, **kwargs):
+        self.calls.append((key, message, kwargs))
+        return DuplexControlResultMessage(
+            control_id=message.control_id,
+            fence=message.fence,
+            operation="touch" if isinstance(message, TouchDuplexSessionMessage) else "resume",
+            session_id=message.session_id,
+            ok=True,
+            stage_results=[],
+        )
+
+
+class _UnsupportedTransport:
+    def execute(self, key, message, **kwargs):
+        del key, kwargs
+        return DuplexControlResultMessage(
+            control_id=message.control_id,
+            fence=message.fence,
+            operation="touch",
+            session_id=message.session_id,
+            ok=False,
+            stage_results=[{"result": {"supported": False}}],
+            unsupported_count=1,
+            error=DuplexControlError(code="invalid_capability", message="unsupported", retryable=False),
+            accepted_fence=DuplexFence(message.session_id, epoch=2),
+            lease_generation=7,
+        )
+
+
+def test_control_client_routes_touch_and_resume_by_control_id() -> None:
+    transport = _Transport()
+    control_ids = iter(("touch-id", "resume-id"))
+    client = DuplexControlClient(transport, control_id_factory=lambda: next(control_ids))
+    fence = DuplexFence("sid-client")
+
+    assert (
+        client.touch(
+            fence.session_id,
+            fence=fence,
+            activity=DuplexLeaseActivity.PLAYBACK_ACK,
+            timeout=2.0,
+        )["ok"]
+        is True
+    )
+    assert (
+        client.resume(
+            fence.session_id,
+            fence=fence,
+            expected_lease_generation=7,
+            timeout=3.0,
+        )["ok"]
+        is True
+    )
+
+    touch_key, touch_message, touch_kwargs = transport.calls[0]
+    assert touch_key == ("duplex", "touch-id")
+    assert isinstance(touch_message, TouchDuplexSessionMessage)
+    assert touch_message.activity == DuplexLeaseActivity.PLAYBACK_ACK.value
+    assert touch_kwargs["timeout"] == 2.0
+
+    resume_key, resume_message, resume_kwargs = transport.calls[1]
+    assert resume_key == ("duplex", "resume-id")
+    assert isinstance(resume_message, ResumeDuplexSessionMessage)
+    assert resume_message.expected_lease_generation == 7
+    assert resume_kwargs["timeout"] == 3.0
+
+
+def test_control_client_treats_ok_false_as_authoritative_failure() -> None:
+    client = DuplexControlClient(_UnsupportedTransport(), control_id_factory=lambda: "unsupported")
+    fence = DuplexFence("sid-unsupported")
+
+    with pytest.raises(DuplexControlRequestError, match="duplex touch failed") as exc_info:
+        client.touch(
+            fence.session_id,
+            fence=fence,
+            activity=DuplexLeaseActivity.HEARTBEAT,
+            timeout=1.0,
+        )
+
+    assert exc_info.value.code == "invalid_capability"
+    assert exc_info.value.retryable is False
+    assert exc_info.value.accepted_fence == DuplexFence(fence.session_id, epoch=2)
+    assert exc_info.value.lease_generation == 7

tests/e2e/features/fullduplex/engine/test_duplex_deploy_config.py

@@ -0,0 +1,68 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Focused tests for typed deployment-only runtime configuration."""
+
+from __future__ import annotations
+
+from dataclasses import FrozenInstanceError
+
+import pytest
+
+from vllm_omni.config.stage_config import (
+    DuplexSessionRuntimeConfig,
+    load_deploy_config,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_duplex_session_runtime_defaults_are_typed_and_immutable(tmp_path) -> None:
+    deploy_path = tmp_path / "duplex.yaml"
+    deploy_path.write_text("duplex_session: {}\nstages: []\n", encoding="utf-8")
+
+    deploy = load_deploy_config(deploy_path)
+
+    assert isinstance(deploy.duplex_session, DuplexSessionRuntimeConfig)
+    assert deploy.duplex_session.idle_ttl_s == 300.0
+    assert deploy.duplex_session.disconnect_grace_s == 30.0
+    assert deploy.duplex_session.reaper_interval_s == 5.0
+    assert deploy.duplex_session.resume_replay_ttl_s == 60.0
+    assert deploy.duplex_session.resume_replay_max_bytes_per_session == 8 * 1024 * 1024
+    assert deploy.duplex_session.max_pending_input_bytes_per_session == 16 * 1024 * 1024
+    assert deploy.duplex_session.max_pending_turns_per_session == 4
+    assert deploy.duplex_session.max_sessions == 1
+    assert deploy.duplex_session.completed_append_cache_size == 256
+    with pytest.raises(FrozenInstanceError):
+        deploy.duplex_session.idle_ttl_s = 1.0  # type: ignore[misc]
+
+
+def test_duplex_session_runtime_accepts_disabled_idle_expiry(tmp_path) -> None:
+    deploy_path = tmp_path / "duplex.yaml"
+    deploy_path.write_text("duplex_session:\n  idle_ttl_s: null\nstages: []\n", encoding="utf-8")
+
+    deploy = load_deploy_config(deploy_path)
+
+    assert deploy.duplex_session.idle_ttl_s is None
+
+
+@pytest.mark.parametrize(
+    ("name", "value"),
+    [
+        ("idle_ttl_s", 0),
+        ("idle_ttl_s", -1),
+        ("disconnect_grace_s", 0),
+        ("reaper_interval_s", -1),
+        ("resume_replay_ttl_s", 0),
+        ("resume_replay_max_bytes_per_session", -1),
+        ("max_pending_input_bytes_per_session", 0),
+        ("max_pending_turns_per_session", -1),
+        ("max_sessions", 0),
+        ("completed_append_cache_size", 0),
+    ],
+)
+def test_duplex_session_runtime_rejects_non_positive_values(tmp_path, name: str, value: int) -> None:
+    deploy_path = tmp_path / "duplex.yaml"
+    deploy_path.write_text(f"duplex_session:\n  {name}: {value}\nstages: []\n", encoding="utf-8")
+
+    with pytest.raises(ValueError, match=rf"duplex_session\.{name} must be positive"):
+        load_deploy_config(deploy_path)

tests/e2e/features/fullduplex/engine/test_duplex_intermediate.py

@@ -0,0 +1,14 @@
+import pytest
+
+from vllm_omni.experimental.fullduplex.engine.intermediate import get_stream_request_key
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_get_stream_request_key_requires_stable_identifier():
+    with pytest.raises(ValueError, match="stable request id"):
+        get_stream_request_key({"ids": {"tts": [1, 2, 3]}})
+
+
+def test_get_stream_request_key_accepts_global_request_id():
+    assert get_stream_request_key({"global_request_id": ["duplex-sid-stage0"]}) == "duplex-sid-stage0"

tests/e2e/features/fullduplex/engine/test_duplex_lease.py

@@ -0,0 +1,224 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from __future__ import annotations
+
+from dataclasses import FrozenInstanceError
+
+import pytest
+
+from vllm_omni.experimental.fullduplex.engine.duplex_runtime import DuplexInputMode
+from vllm_omni.experimental.fullduplex.engine.duplex_session import DuplexSessionRuntimeManager
+from vllm_omni.experimental.fullduplex.engine.lease import (
+    DuplexLeaseActivity,
+    DuplexLeaseConfig,
+)
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+class FakeMonotonicClock:
+    def __init__(self, value: float) -> None:
+        self.value = value
+
+    def __call__(self) -> float:
+        return self.value
+
+    def advance(self, seconds: float) -> None:
+        self.value += seconds
+
+
+def _lease_config(*, idle_ttl_s: float | None = 300.0) -> DuplexLeaseConfig:
+    return DuplexLeaseConfig(
+        idle_ttl_s=idle_ttl_s,
+        disconnect_grace_s=30.0,
+    )
+
+
+def test_open_touch_detach_and_idle_expiry_use_monotonic_time() -> None:
+    clock = FakeMonotonicClock(100.0)
+    manager = DuplexSessionRuntimeManager(clock=clock)
+    fence = DuplexFence("sid-expiry")
+    session = manager.open_session(fence, lease_config=_lease_config())
+
+    assert session.lease.last_activity == 100.0
+    clock.advance(10.0)
+    session.touch(fence, DuplexLeaseActivity.HEARTBEAT)
+    session.detach(fence)
+    clock.advance(29.0)
+    assert session.lease.disconnect_grace_expired(clock()) is False
+    assert manager.collect_expired() == []
+
+    clock.advance(272.0)
+    expired = manager.collect_expired()
+
+    assert [item.session_id for item in expired] == ["sid-expiry"]
+    assert expired[0].reason == "disconnect_grace_expired"
+    assert manager.get("sid-expiry") is session
+    manager.finalize_close_session(session)
+    assert manager.get("sid-expiry") is None
+
+
+def test_detach_grace_and_resume_advance_token_independent_lease_generation() -> None:
+    clock = FakeMonotonicClock(10.0)
+    manager = DuplexSessionRuntimeManager(clock=clock)
+    fence = DuplexFence("sid-resume")
+    session = manager.open_session(fence, lease_config=_lease_config())
+
+    session.detach(fence)
+    clock.advance(29.0)
+    assert session.lease.disconnect_grace_expired(clock()) is False
+    clock.advance(2.0)
+    assert session.lease.disconnect_grace_expired(clock()) is True
+
+    generation = session.resume(fence, expected_lease_generation=0)
+
+    assert generation == 1
+    assert session.lease.detached_at is None
+    assert session.lease.disconnect_grace_expired(clock()) is False
+    with pytest.raises(ValueError, match="lease generation mismatch"):
+        session.resume(fence, expected_lease_generation=0)
+
+
+def test_active_operation_prevents_mid_transaction_expiry() -> None:
+    clock = FakeMonotonicClock(0.0)
+    manager = DuplexSessionRuntimeManager(clock=clock)
+    fence = DuplexFence("sid-operation")
+    session = manager.open_session(fence, lease_config=_lease_config(idle_ttl_s=5.0))
+
+    session.begin_operation(fence, "append-1")
+    clock.advance(10.0)
+    assert manager.collect_expired() == []
+
+    session.end_operation(fence, "append-1")
+    assert manager.collect_expired() == []
+    clock.advance(6.0)
+    assert [item.session_id for item in manager.collect_expired()] == ["sid-operation"]
+
+
+def test_sessions_have_independent_activity_deadlines_and_resources() -> None:
+    clock = FakeMonotonicClock(0.0)
+    manager = DuplexSessionRuntimeManager(clock=clock)
+    fence_a = DuplexFence("sid-a")
+    fence_b = DuplexFence("sid-b")
+    session_a = manager.open_session(fence_a, lease_config=_lease_config(idle_ttl_s=10.0))
+    session_b = manager.open_session(fence_b, lease_config=_lease_config(idle_ttl_s=10.0))
+    session_a.reserve_stage_request(0, "req-a-reserved", fence=fence_a)
+    session_a.bind_stage_request(1, "req-a-submitted", fence=fence_a)
+    session_b.bind_stage_request(0, "req-b", fence=fence_b)
+
+    clock.advance(6.0)
+    session_b.touch(fence_b, DuplexLeaseActivity.MODEL_OUTPUT)
+    clock.advance(5.0)
+    expired = manager.collect_expired()
+
+    assert len(expired) == 1
+    assert expired[0].session_id == "sid-a"
+    assert expired[0].reserved_request_ids == ("req-a-reserved",)
+    assert expired[0].submitted_request_ids == ("req-a-submitted",)
+    assert manager.get("sid-b") is session_b
+    assert session_b.resource_request_ids() == ["req-b"]
+
+
+def test_close_and_reaper_select_exactly_one_terminal_transition() -> None:
+    clock = FakeMonotonicClock(0.0)
+    manager = DuplexSessionRuntimeManager(clock=clock)
+    fence = DuplexFence("sid-race")
+    manager.open_session(fence, lease_config=_lease_config(idle_ttl_s=1.0))
+    clock.advance(2.0)
+
+    assert len(manager.collect_expired()) == 1
+    assert manager.close_session(fence, reason="explicit_close") is None
+    assert manager.collect_expired() == []
+
+    fence_2 = DuplexFence("sid-race-2")
+    manager.open_session(fence_2, lease_config=_lease_config(idle_ttl_s=1.0))
+    assert manager.close_session(fence_2, reason="explicit_close") is not None
+    clock.advance(2.0)
+    assert manager.collect_expired() == []
+
+
+def test_stale_fence_cannot_touch_detach_or_resume_lease() -> None:
+    clock = FakeMonotonicClock(0.0)
+    manager = DuplexSessionRuntimeManager(clock=clock)
+    current = DuplexFence("sid-fence", epoch=1)
+    stale = DuplexFence("sid-fence", epoch=0)
+    session = manager.open_session(current, lease_config=_lease_config())
+
+    with pytest.raises(RuntimeError, match="fence mismatch"):
+        session.touch(stale, DuplexLeaseActivity.APPEND)
+    with pytest.raises(RuntimeError, match="fence mismatch"):
+        session.detach(stale)
+    with pytest.raises(RuntimeError, match="fence mismatch"):
+        session.resume(stale, expected_lease_generation=0)
+
+
+def test_disabled_idle_expiry_never_collects_session() -> None:
+    clock = FakeMonotonicClock(0.0)
+    manager = DuplexSessionRuntimeManager(clock=clock)
+    manager.open_session(DuplexFence("sid-no-expiry"), lease_config=_lease_config(idle_ttl_s=None))
+
+    clock.advance(1_000_000.0)
+
+    assert manager.collect_expired() == []
+
+
+def test_detached_session_expires_at_disconnect_grace_when_idle_ttl_is_disabled() -> None:
+    clock = FakeMonotonicClock(0.0)
+    manager = DuplexSessionRuntimeManager(clock=clock)
+    fence = DuplexFence("sid-disconnect-grace")
+    session = manager.open_session(fence, lease_config=_lease_config(idle_ttl_s=None))
+
+    session.detach(fence)
+    clock.advance(29.0)
+    assert manager.collect_expired() == []
+
+    clock.advance(1.0)
+    expired = manager.collect_expired()
+
+    assert [item.session_id for item in expired] == [fence.session_id]
+    assert expired[0].reason == "disconnect_grace_expired"
+
+
+def test_runtime_manager_enforces_server_owned_session_admission() -> None:
+    manager = DuplexSessionRuntimeManager(max_sessions=2)
+    manager.open_session(DuplexFence("sid-admission-a"))
+    manager.open_session(DuplexFence("sid-admission-b"))
+
+    with pytest.raises(RuntimeError, match="duplex_session_capacity_exhausted"):
+        manager.open_session(DuplexFence("sid-admission-c"))
+
+
+def test_completed_append_cache_is_bounded() -> None:
+    manager = DuplexSessionRuntimeManager(completed_append_limit=2)
+    fence = DuplexFence("sid-completed-cache")
+    session = manager.open_session(fence)
+
+    for index in range(3):
+        session.record_completed_append(
+            f"operation-{index}",
+            fence=fence,
+            mode=DuplexInputMode.TURN_COMMIT_ONLY,
+            final=True,
+            stage_results=[{"index": index}],
+        )
+
+    assert list(session.completed_appends) == ["operation-1", "operation-2"]
+
+    session.accept_fence(DuplexFence(fence.session_id, epoch=1))
+    assert session.completed_appends == {}
+
+
+def test_lease_config_and_expiry_record_are_immutable() -> None:
+    config = _lease_config()
+    with pytest.raises(FrozenInstanceError):
+        config.idle_ttl_s = 1.0  # type: ignore[misc]
+
+    clock = FakeMonotonicClock(0.0)
+    manager = DuplexSessionRuntimeManager(clock=clock)
+    manager.open_session(DuplexFence("sid-record"), lease_config=_lease_config(idle_ttl_s=1.0))
+    clock.advance(2.0)
+    record = manager.collect_expired()[0]
+    with pytest.raises(FrozenInstanceError):
+        record.reason = "changed"  # type: ignore[misc]

tests/e2e/features/fullduplex/engine/test_duplex_runtime.py

@@ -0,0 +1,480 @@
+from dataclasses import FrozenInstanceError
+from types import SimpleNamespace
+
+import pytest
+from vllm.sampling_params import SamplingParams
+
+from vllm_omni.experimental.fullduplex.engine import duplex_runtime
+from vllm_omni.experimental.fullduplex.engine.contracts import (
+    duplex_data_plane_request_info,
+    duplex_resource_request_belongs_to_session,
+    duplex_resource_request_id,
+)
+from vllm_omni.experimental.fullduplex.engine.duplex_runtime import (
+    DuplexInputMode,
+    DuplexOutputAction,
+    DuplexOutputDecision,
+    DuplexRuntimeCapabilities,
+    DuplexSessionRuntimeManager,
+)
+from vllm_omni.experimental.fullduplex.engine.messages import DuplexFence
+from vllm_omni.experimental.fullduplex.minicpmo45.runtime import (
+    MiniCPMO45DuplexRuntimeExtension,
+    build_duplex_data_plane_prompt,
+    duplex_scheduler_token_budget,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_duplex_fence_is_immutable():
+    fence = DuplexFence("session")
+
+    with pytest.raises(FrozenInstanceError):
+        fence.epoch = 1  # type: ignore[misc]
+
+    assert not hasattr(fence, "__dict__")
+
+
+def test_duplex_runtime_tracks_stage_bindings_and_barge_in_epoch():
+    manager = DuplexSessionRuntimeManager()
+    session = manager.open_session(
+        DuplexFence("sid-1"),
+        capabilities=DuplexRuntimeCapabilities(
+            input_modes={DuplexInputMode.APPEND_TOKENS},
+        ),
+    )
+    session.bind_stage_request(stage_id=0, request_id="req-stage0", fence=session.fence)
+    session.bind_stage_request(stage_id=1, request_id="req-stage1", fence=session.fence)
+
+    update = session.append_input(mode=DuplexInputMode.APPEND_TOKENS, fence=session.fence)
+    next_fence = DuplexFence("sid-1", epoch=1)
+    stale_request_ids = session.release_fence(session.fence)
+    session.accept_fence(next_fence)
+
+    assert update.seq == 1
+    assert session.fence == next_fence
+    assert stale_request_ids == ["req-stage0", "req-stage1"]
+    assert session.stage_bindings == {}
+
+
+def test_duplex_runtime_tracks_same_request_id_for_each_pipeline_stage():
+    manager = DuplexSessionRuntimeManager()
+    fence = DuplexFence("sid-shared-pipeline-request")
+    session = manager.open_session(fence)
+
+    session.reserve_stage_request(0, "req-shared", fence=fence)
+    session.bind_stage_request(0, "req-shared", fence=fence)
+    session.bind_stage_request(1, "req-shared", fence=fence)
+
+    assert session.stage_bindings[0].request_id == "req-shared"
+    assert session.stage_bindings[1].request_id == "req-shared"
+    assert session.resource_request_ids() == ["req-shared"]
+    assert session.input_seq == 0
+
+
+def test_duplex_runtime_extension_validation_rejects_missing_methods():
+    class IncompleteExtension:
+        def configure_sampling_params(self, *, runtime_config, defaults):
+            del runtime_config
+            return defaults
+
+    with pytest.raises(TypeError, match="plan_append"):
+        duplex_runtime.validate_duplex_runtime_extension(IncompleteExtension())
+
+
+def test_duplex_runtime_extension_validation_rejects_stage_count_mismatch():
+    class WrongStageCountExtension(MiniCPMO45DuplexRuntimeExtension):
+        def configure_sampling_params(self, *, runtime_config, defaults):
+            del runtime_config
+            return defaults[:1]
+
+    with pytest.raises(ValueError, match="one sampling parameter per stage"):
+        duplex_runtime.validate_duplex_runtime_extension(
+            WrongStageCountExtension(),
+            sampling_defaults=(SamplingParams(), SamplingParams()),
+        )
+
+
+def test_duplex_runtime_extension_validation_rejects_sampling_type_mismatch():
+    class WrongSamplingTypeExtension(MiniCPMO45DuplexRuntimeExtension):
+        def configure_sampling_params(self, *, runtime_config, defaults):
+            del runtime_config
+            return tuple(object() for _ in defaults)
+
+    with pytest.raises(TypeError, match="sampling parameter type"):
+        duplex_runtime.validate_duplex_runtime_extension(
+            WrongSamplingTypeExtension(),
+            sampling_defaults=(SamplingParams(), SamplingParams()),
+        )
+
+
+def test_duplex_output_decision_metadata_is_immutable():
+    decision = DuplexOutputDecision(
+        action=DuplexOutputAction.DIRECT_RESPONSE,
+        metadata={"model_listen": True},
+    )
+
+    with pytest.raises(TypeError):
+        decision.metadata["model_listen"] = False
+
+
+def _decide_minicpmo_output(
+    output: object,
+    *,
+    segment_token_ids: tuple[int, ...] = (),
+    segment_output_metadata: dict | None = None,
+):
+    return MiniCPMO45DuplexRuntimeExtension().decide_output(
+        stage_id=0,
+        final_stage_id=1,
+        segment_finished=True,
+        segment_token_ids=segment_token_ids,
+        segment_output_metadata=segment_output_metadata or {},
+        output=output,
+    )
+
+
+def test_minicpmo_extension_owns_stage_sampling_overrides():
+    defaults = (
+        SamplingParams(max_tokens=4),
+        SamplingParams(max_tokens=8),
+    )
+
+    configured = MiniCPMO45DuplexRuntimeExtension().configure_sampling_params(
+        runtime_config={
+            "duplex_stage_max_tokens": {"0": 20},
+            "duplex_stage_sampling_params": {"1": {"stop_token_ids": [151645]}},
+        },
+        defaults=defaults,
+    )
+
+    assert configured[0].max_tokens == 20
+    assert configured[1].stop_token_ids == [151645]
+    assert defaults[0].max_tokens == 4
+    assert 151645 not in (defaults[1].stop_token_ids or [])
+
+
+def test_minicpmo_output_decision_uses_raw_streaming_token_snapshot():
+    decision = _decide_minicpmo_output(
+        SimpleNamespace(outputs=[SimpleNamespace()]),
+        segment_token_ids=(151705,),
+        segment_output_metadata={"special_token_ids": {"listen_token_id": 151705}},
+    )
+
+    assert decision is not None
+    assert decision.action is DuplexOutputAction.DIRECT_RESPONSE
+    assert decision.metadata["duplex_native_decision"] == "listen"
+    assert decision.metadata["model_listen"] is True
+
+
+@pytest.mark.parametrize("attr", ["token_ids", "cumulative_token_ids"])
+def test_minicpmo_output_decision_ignores_output_level_token_history(attr):
+    output = SimpleNamespace(
+        multimodal_output={"special_token_ids": {"listen_token_id": 151705}},
+        outputs=[SimpleNamespace()],
+        **{attr: [42, 151705]},
+    )
+
+    assert _decide_minicpmo_output(output) is None
+
+
+@pytest.mark.parametrize("attr", ["token_ids", "cumulative_token_ids"])
+def test_minicpmo_output_decision_uses_completion_token_ids(attr):
+    output = SimpleNamespace(
+        multimodal_output={"special_token_ids": {"listen_token_id": 151705}},
+        outputs=[SimpleNamespace(**{attr: [42, 151705]})],
+    )
+
+    assert _decide_minicpmo_output(output) is not None
+
+
+def test_minicpmo_output_decision_uses_completion_stop_reason():
+    output = SimpleNamespace(
+        multimodal_output={"special_token_ids": {"listen_token_id": 151705}},
+        outputs=[SimpleNamespace(stop_reason=151705)],
+    )
+
+    assert _decide_minicpmo_output(output) is not None
+
+
+def test_duplex_runtime_cancel_fence_rejects_late_append_and_accepts_next_epoch():
+    manager = DuplexSessionRuntimeManager()
+    cancelled_fence = DuplexFence("sid-cancel-race")
+    next_fence = DuplexFence("sid-cancel-race", epoch=1)
+    session = manager.open_session(
+        cancelled_fence,
+        capabilities=DuplexRuntimeCapabilities(
+            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
+        ),
+    )
+    session.bind_stage_request(
+        stage_id=0,
+        request_id="req-cancelled",
+        fence=cancelled_fence,
+    )
+
+    stale_request_ids = session.cancel_fence(cancelled_fence, next_fence)
+
+    assert stale_request_ids == ["req-cancelled"]
+    assert session.fence == next_fence
+    assert session.stage_bindings == {}
+    with pytest.raises(RuntimeError, match="fence mismatch"):
+        session.append_input(
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+            fence=cancelled_fence,
+        )
+    update = session.append_input(
+        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+        fence=next_fence,
+    )
+    assert update.seq == 1
+
+
+def test_duplex_runtime_stale_close_preserves_live_session_and_bindings():
+    manager = DuplexSessionRuntimeManager()
+    current_fence = DuplexFence("sid-stale-close", epoch=1)
+    session = manager.open_session(
+        current_fence,
+        capabilities=DuplexRuntimeCapabilities(
+            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
+        ),
+    )
+    session.bind_stage_request(0, "req-live", fence=current_fence)
+
+    with pytest.raises(RuntimeError, match="fence mismatch"):
+        manager.close_session(DuplexFence("sid-stale-close"))
+
+    assert manager.get("sid-stale-close") is session
+    assert session.stage_request_ids() == ["req-live"]
+
+
+def test_duplex_runtime_reopen_rejects_late_append_from_old_incarnation():
+    manager = DuplexSessionRuntimeManager()
+    old_fence = DuplexFence("sid-reopen", incarnation=0)
+    old_session = manager.open_session(
+        old_fence,
+        capabilities=DuplexRuntimeCapabilities(
+            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
+        ),
+    )
+    manager.close_session(old_fence)
+
+    new_fence = DuplexFence("sid-reopen", incarnation=1)
+    new_session = manager.open_session(
+        new_fence,
+        capabilities=old_session.capabilities,
+    )
+
+    with pytest.raises(RuntimeError, match="fence mismatch"):
+        new_session.append_input(
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+            fence=old_fence,
+        )
+    assert (
+        new_session.append_input(
+            mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+            fence=new_fence,
+        ).seq
+        == 1
+    )
+
+
+def test_duplex_prompt_expands_incarnation_metadata():
+    fence = DuplexFence("sid-incarnation", incarnation=3)
+
+    prompt = build_duplex_data_plane_prompt(
+        request_id=duplex_resource_request_id(fence, "stage0"),
+        fence=fence,
+        session_config={},
+        runtime_config={},
+        seq=1,
+        turn_seq=1,
+        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+        payload={"is_speech": True},
+        final=False,
+    )
+
+    assert prompt["model_intermediate_buffer"]["duplex"]["incarnation"] == 3
+
+
+def test_duplex_runtime_tracks_turn_local_append_sequence():
+    manager = DuplexSessionRuntimeManager()
+    session = manager.open_session(
+        DuplexFence("sid-turn-seq"),
+        capabilities=DuplexRuntimeCapabilities(
+            input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK},
+        ),
+    )
+
+    first = session.append_input(mode=DuplexInputMode.APPEND_AUDIO_CHUNK, fence=session.fence)
+    second = session.append_input(mode=DuplexInputMode.APPEND_AUDIO_CHUNK, fence=session.fence)
+    next_turn = DuplexFence("sid-turn-seq", turn_id=1, response_seq=1)
+    third = session.append_input(
+        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+        fence=next_turn,
+    )
+    fourth = session.append_input(
+        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+        fence=next_turn,
+    )
+
+    assert [first.seq, second.seq, third.seq, fourth.seq] == [1, 2, 3, 4]
+    assert [first.turn_seq, second.turn_seq, third.turn_seq, fourth.turn_seq] == [1, 2, 1, 2]
+    assert [first.turn_id, second.turn_id, third.turn_id, fourth.turn_id] == [0, 0, 1, 1]
+
+
+def test_duplex_runtime_rejects_unsupported_append_mode():
+    manager = DuplexSessionRuntimeManager()
+    session = manager.open_session(
+        DuplexFence("sid-2"),
+        capabilities=DuplexRuntimeCapabilities(input_modes={DuplexInputMode.TURN_COMMIT_ONLY}),
+    )
+
+    with pytest.raises(ValueError, match="not supported"):
+        session.append_input(mode=DuplexInputMode.APPEND_TOKENS, fence=session.fence)
+
+
+def test_duplex_data_plane_request_info_extracts_structured_stage_result():
+    request_id, response_stage_id = duplex_data_plane_request_info(
+        {
+            "stage_results": [
+                {"result": {"supported": True}},
+                {
+                    "result": {
+                        "data_plane_append": True,
+                        "request_id": "duplex-sid-e0-stage0-s1",
+                        "response_stage_id": 1,
+                    }
+                },
+            ]
+        }
+    )
+
+    assert request_id == "duplex-sid-e0-stage0-s1"
+    assert response_stage_id == 1
+
+
+def test_duplex_data_plane_request_info_rejects_missing_request_id():
+    assert duplex_data_plane_request_info(
+        {
+            "stage_results": [
+                {
+                    "result": {
+                        "data_plane_append": True,
+                        "request_id": "",
+                        "response_stage_id": 1,
+                    }
+                }
+            ]
+        }
+    ) == (None, None)
+
+
+def test_duplex_scheduler_token_budget_estimates_pcm_slots():
+    assert (
+        duplex_scheduler_token_budget(
+            {
+                "audio": "AAAAAA==",
+                "format": "pcm_f32le",
+                "sample_rate_hz": 16000,
+            }
+        )
+        == 16
+    )
+
+
+def test_duplex_scheduler_token_budget_ignores_client_budget_fields():
+    assert (
+        duplex_scheduler_token_budget(
+            {
+                "audio": "AAAAAA==",
+                "format": "pcm_f32le",
+                "duplex_num_input_tokens": 999,
+                "num_input_tokens": 999,
+            }
+        )
+        == 16
+    )
+
+
+def test_resource_state_rejects_fence_regression_and_requires_explicit_fence():
+    current = DuplexFence("sid", epoch=2, turn_id=3, response_seq=4)
+    manager = DuplexSessionRuntimeManager()
+    session = manager.open_session(
+        current,
+        capabilities=DuplexRuntimeCapabilities(input_modes={DuplexInputMode.APPEND_AUDIO_CHUNK}),
+    )
+
+    for stale in (
+        DuplexFence("sid", epoch=1, turn_id=99, response_seq=99),
+        DuplexFence("sid", epoch=2, turn_id=2, response_seq=4),
+        DuplexFence("sid", epoch=2, turn_id=3, response_seq=3),
+    ):
+        with pytest.raises(RuntimeError, match="fence mismatch"):
+            session.accept_fence(stale)
+        assert session.fence == current
+
+    with pytest.raises(TypeError, match="fence"):
+        session.bind_stage_request(0, "request")
+    with pytest.raises(TypeError, match="fence"):
+        session.append_input(mode=DuplexInputMode.APPEND_AUDIO_CHUNK)
+    with pytest.raises(TypeError, match="DuplexFence"):
+        manager.open_session("legacy-session")
+    with pytest.raises(TypeError, match="DuplexFence"):
+        manager.close_session("legacy-session")
+
+
+def test_resource_request_id_is_derived_from_fence_and_role():
+    fence = DuplexFence("sid-with-dashes", epoch=7, turn_id=11, response_seq=13)
+
+    assert duplex_resource_request_id(fence, "stage0") == "duplex-s.c2lkLXdpdGgtZGFzaGVz.i.0.e.7.r.stage0"
+    assert duplex_resource_request_id(fence, "stage1") == "duplex-s.c2lkLXdpdGgtZGFzaGVz.i.0.e.7.r.stage1"
+
+
+def test_resource_request_id_codec_separates_session_id_from_incarnation():
+    embedded_incarnation = duplex_resource_request_id(
+        DuplexFence("foo-i1", incarnation=0),
+        "stage0",
+    )
+    actual_incarnation = duplex_resource_request_id(
+        DuplexFence("foo", incarnation=1),
+        "stage0",
+    )
+
+    assert embedded_incarnation != actual_incarnation
+
+
+def test_resource_request_id_session_membership_uses_encoded_identity():
+    request_id = duplex_resource_request_id(
+        DuplexFence("sid-with-dashes", incarnation=2, epoch=7),
+        "stage0",
+    )
+
+    assert duplex_resource_request_belongs_to_session(request_id, "sid-with-dashes") is True
+    assert duplex_resource_request_belongs_to_session(request_id, "sid") is False
+    assert duplex_resource_request_belongs_to_session("duplex-s.invalid.i.x.e.7.r.stage0", "sid") is False
+
+
+def test_placeholder_budget_is_planned_inside_omni_engine_boundary():
+    fence = DuplexFence("sid", turn_id=1, response_seq=1)
+    prompt = build_duplex_data_plane_prompt(
+        request_id=duplex_resource_request_id(fence, "stage0"),
+        fence=fence,
+        session_config={},
+        runtime_config={},
+        seq=2,
+        turn_seq=1,
+        mode=DuplexInputMode.APPEND_AUDIO_CHUNK,
+        payload={
+            "audio": "AAAAAA==",
+            "format": "pcm_f32le",
+            "duplex_num_input_tokens": 999,
+            "num_input_tokens": 999,
+        },
+        final=False,
+    )
+
+    assert len(prompt["prompt_token_ids"]) == 16
+    assert prompt["model_intermediate_buffer"]["duplex"]["fence"] == fence
+    assert prompt["model_intermediate_buffer"]["duplex"]["scheduler_token_budget"] == 16