Skip to content
141 changes: 141 additions & 0 deletions tests/reasoning/test_kimi_k3_reasoning_parser.py
Original file line number Diff line number Diff line change
Expand Up @@ -13,6 +13,7 @@
from vllm.parser.parser_manager import ParserManager
from vllm.reasoning.kimi_k3_reasoning_parser import KimiK3ReasoningParser
from vllm.tokenizers import TokenizerLike
from vllm.tool_parsers.kimi_k3_tool_parser import KimiK3ToolParser

pytestmark = pytest.mark.skip_global_cleanup

Expand Down Expand Up @@ -50,6 +51,10 @@ class ReasoningOnlyParser(KimiK3Parser):
reasoning_parser_cls = KimiK3ReasoningParser


class ReasoningAndToolParser(ReasoningOnlyParser):
tool_parser_cls = KimiK3ToolParser


def test_parser_manager_selects_kimi_k3_parser_for_reasoning_only():
parser_cls = ParserManager.get_parser(reasoning_parser_name="kimi_k3")

Expand Down Expand Up @@ -301,6 +306,142 @@ def test_delegating_parser_thinking_false_streams_response_content():
assert closed is None


@pytest.mark.parametrize("suffix", ["<", OPEN, f"{CLOSE}think"])
@pytest.mark.parametrize("prefix", ["", "value "])
@pytest.mark.parametrize("empty_final", [False, True])
@pytest.mark.parametrize("parser_cls", [ReasoningOnlyParser, ReasoningAndToolParser])
def test_streaming_eof_preserves_unfinished_reasoning_marker(
suffix, prefix, empty_final, parser_cls
):
parser = parser_cls(_dummy_tokenizer())
request = ChatCompletionRequest(model="test-model", messages=[])
text = prefix + suffix
chunks = [text, ""] if empty_final else [text]
deltas = [
parser.parse_delta(
chunk,
parser.model_tokenizer.encode(chunk),
request,
prompt_token_ids=OPEN_IDS,
finished=index == len(chunks) - 1,
)
for index, chunk in enumerate(chunks)
]

assert "".join(delta.reasoning or "" for delta in deltas if delta) == text
assert not any(delta.content or delta.tool_calls for delta in deltas if delta)


@pytest.mark.parametrize("thinking", [False, True])
@pytest.mark.parametrize("suffix", ["<", f"{CLOSE}response"])
@pytest.mark.parametrize("prefix", ["", "value "])
@pytest.mark.parametrize("empty_final", [False, True])
@pytest.mark.parametrize("parser_cls", [ReasoningOnlyParser, ReasoningAndToolParser])
def test_streaming_eof_preserves_unfinished_content_marker(
thinking, suffix, prefix, empty_final, parser_cls
):
parser = parser_cls(_dummy_tokenizer(), chat_template_kwargs={"thinking": thinking})
request = ChatCompletionRequest(model="test-model", messages=[])
chunks = ["step", THINK_CLOSE] if thinking else []
chunks += [RESPONSE_OPEN, prefix + suffix]
if empty_final:
chunks.append("")
deltas = [
parser.parse_delta(
chunk,
parser.model_tokenizer.encode(chunk),
request,
prompt_token_ids=OPEN_IDS,
finished=index == len(chunks) - 1,
)
for index, chunk in enumerate(chunks)
]

assert "".join(delta.content or "" for delta in deltas if delta) == prefix + suffix
assert "".join(delta.reasoning or "" for delta in deltas if delta) == (
"step" if thinking else ""
)
assert not any(delta.tool_calls for delta in deltas if delta)


@pytest.mark.parametrize("parser_cls", [ReasoningOnlyParser, ReasoningAndToolParser])
def test_streaming_eof_does_not_expose_suppressed_reasoning(parser_cls):
parser = parser_cls(_dummy_tokenizer())
request = ChatCompletionRequest(
model="test-model", messages=[], include_reasoning=False
)

assert (
parser.parse_delta(
"value <", [9], request, prompt_token_ids=OPEN_IDS, finished=True
)
is None
)


def test_streaming_eof_does_not_expose_other_parser_reasoning():
class Tokenizer(DummyTokenizer):
def get_vocab(self):
return {"<think>": 1000, "</think>": 1001}

def encode(self, text, add_special_tokens=False):
if text in self.get_vocab():
return [self.get_vocab()[text]]
return super().encode(text, add_special_tokens=add_special_tokens)

parser_cls = ParserManager.get_parser(
reasoning_parser_name="deepseek_r1",
tool_parser_name="kimi_k3",
enable_auto_tools=True,
)
assert parser_cls is not None
parser = parser_cls(cast(TokenizerLike, Tokenizer()))
request = ChatCompletionRequest(
model="test-model", messages=[], include_reasoning=False
)

assert (
parser.parse_delta(
"internal thought <", [9], request, prompt_token_ids=[1000], finished=True
)
is None
)


@pytest.mark.parametrize("parser_cls", [ReasoningOnlyParser, ReasoningAndToolParser])
@pytest.mark.parametrize("empty_final", [False, True])
def test_streaming_eof_strips_complete_markers_after_reasoning(parser_cls, empty_final):
parser = parser_cls(_dummy_tokenizer())
request = ChatCompletionRequest(model="test-model", messages=[])
# A speculative step can close reasoning and complete the response together.
chunks = [
(THINK_OPEN + "step", [*OPEN_IDS, 9]),
(
THINK_CLOSE
+ RESPONSE_OPEN
+ "answer"
+ f"{CLOSE}response{SEP}{CLOSE}message{SEP}",
[*CLOSE_IDS, 10],
),
]
if empty_final:
chunks.append(("", []))
deltas = [
parser.parse_delta(
chunk,
token_ids,
request,
prompt_token_ids=OPEN_IDS,
finished=index == len(chunks) - 1,
)
for index, (chunk, token_ids) in enumerate(chunks)
]

assert "".join(delta.reasoning or "" for delta in deltas if delta) == "step"
assert "".join(delta.content or "" for delta in deltas if delta) == "answer"
assert not any(delta.tool_calls for delta in deltas if delta)


def test_adjust_request_keeps_xtml_markers_contiguous():
parser = KimiK3ReasoningParser(DummyTokenizer())
request = ChatCompletionRequest(model="test-model", messages=[])
Expand Down
6 changes: 4 additions & 2 deletions tests/v1/kv_connector/unit/test_moriio_hma_scheduler.py
Original file line number Diff line number Diff line change
Expand Up @@ -828,7 +828,7 @@ def test_get_num_new_matched_tokens_read_recomputes_last_token():
req = SimpleNamespace(
num_prompt_tokens=10,
prompt_token_ids=list(range(10)),
kv_transfer_params=None,
kv_transfer_params={"do_remote_prefill": True},
)
n, is_async = sched.get_num_new_matched_tokens(req, num_computed_tokens=0)
# READ always recomputes the final token locally: N-1 - computed.
Expand Down Expand Up @@ -865,7 +865,9 @@ def test_get_num_new_matched_tokens_supports_embeds_only_prompts(
num_prompt_tokens=10,
prompt_token_ids=None,
prompt_embeds=object(),
kv_transfer_params=None,
kv_transfer_params={"do_remote_prefill": True}
if mode == MoRIIOMode.READ
else None,
)

assert sched.get_num_new_matched_tokens(req, num_computed_tokens) == (
Expand Down
33 changes: 33 additions & 0 deletions tests/v1/kv_connector/unit/test_moriio_routing.py
Original file line number Diff line number Diff line change
Expand Up @@ -14,6 +14,10 @@

from types import SimpleNamespace

import pytest

from vllm.config import KVTransferConfig
from vllm.distributed.kv_transfer.kv_connector.v1.moriio import moriio_common
from vllm.distributed.kv_transfer.kv_connector.v1.moriio.moriio_connector import (
MoRIIOConnectorScheduler,
)
Expand All @@ -23,6 +27,35 @@
_clip_blocks = MoRIIOConnectorScheduler.get_exchange_clipped_blocks


@pytest.mark.parametrize("backend, expected_port", [("rdma", 0), ("xgmi", 12345)])
def test_rdma_listener_reserves_port_during_bind(monkeypatch, backend, expected_port):
monkeypatch.setattr(moriio_common, "get_tensor_model_parallel_rank", lambda: 0)
monkeypatch.setattr(
moriio_common, "get_tensor_model_parallel_world_size", lambda: 8
)
monkeypatch.setattr(moriio_common, "get_open_port", lambda: 12345)
monkeypatch.setattr(moriio_common, "resolve_host_ip", lambda _: "127.0.0.1")
config = SimpleNamespace(
kv_transfer_config=KVTransferConfig(
kv_connector="MoRIIOConnector",
kv_role="kv_producer",
kv_connector_extra_config={
"backend": backend,
"http_port": 8000,
"handshake_port": 6300,
"notify_port": 7300,
},
),
parallel_config=SimpleNamespace(
data_parallel_rank=0, data_parallel_size=1, data_parallel_size_local=1
),
)
assert (
moriio_common.MoRIIOConfig.from_vllm_config(config).local_kv_port
== expected_port
)


def _producer(global_dp_rank: int, dp_size: int, dp_size_local: int):
"""Minimal prefill-side (producer) scheduler stand-in for request_finished."""
s = SimpleNamespace(
Expand Down
Loading
Loading