[MyPy][3/N] Fix MyPy errors in test groups (part 3) (#55939)

Signed-off-by: Taimys <ffy2281693949@gmail.com>
Signed-off-by: Luyi Xiao <81631911+luyixiao95@users.noreply.github.com>
Signed-off-by: Harry Mellor <19981378+hmellor@users.noreply.github.com>
Co-authored-by: Codex <noreply@openai.com>
Co-authored-by: Luyi Xiao <81631911+luyixiao95@users.noreply.github.com>
Co-authored-by: Taimys <ffy2281693949@gmail.com>
Co-authored-by: Harry Mellor <19981378+hmellor@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Taimys
2026-09-30 11:06:07 +00:00
committed by GitHub
co-authored by Codex Luyi Xiao Taimys Harry Mellor Claude Opus 5.5
parent c4fa6f36a7
commit 5225f1bacb
118 changed files with 948 additions and 605 deletions
@@ -2,7 +2,7 @@
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
import pytest
from transformers import AutoTokenizer
from transformers import AutoTokenizer, PreTrainedTokenizerBase
from tests.reasoning.utils import run_reasoning_extraction
from vllm.entrypoints.openai.chat_completion.protocol import ChatCompletionRequest
@@ -39,8 +39,10 @@ REASONING_MODEL_NAME = "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"
@pytest.fixture(scope="module")
def test_tokenizer():
tokenizer = AutoTokenizer.from_pretrained(REASONING_MODEL_NAME)
def test_tokenizer() -> PreTrainedTokenizerBase:
tokenizer: PreTrainedTokenizerBase = AutoTokenizer.from_pretrained(
REASONING_MODEL_NAME
)
# Add custom test tokens
test_tokens = ["<test:think>", "</test:think>", "<alt:start>", "<alt:end>"]
existing_tokens = set(tokenizer.get_vocab().keys())
@@ -66,7 +68,7 @@ class TestBaseThinkingReasoningParserInit:
def test_initialization_with_missing_tokenizer(self):
"""Test that initialization fails without tokenizer."""
with pytest.raises(ValueError, match="model tokenizer must be passed"):
TestThinkingReasoningParser(None)
TestThinkingReasoningParser(None) # type: ignore[arg-type]
def test_initialization_with_missing_tokens(self, test_tokenizer):
"""Test that initialization fails when tokens are not in vocabulary."""
@@ -2,7 +2,7 @@
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
import pytest
from transformers import AutoTokenizer
from transformers import AutoTokenizer, PreTrainedTokenizerBase
from tests.reasoning.utils import run_reasoning_extraction
from vllm.reasoning import ReasoningParser, ReasoningParserManager
@@ -15,7 +15,7 @@ REASONING_MODEL_NAME = "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"
@pytest.fixture(scope="module")
def deepseek_r1_qwen_tokenizer():
def deepseek_r1_qwen_tokenizer() -> PreTrainedTokenizerBase:
return AutoTokenizer.from_pretrained(REASONING_MODEL_NAME)
@@ -279,10 +279,10 @@ def test_reasoning(
# Test extract_content
if param_dict["content"] is not None:
content = parser.extract_content_ids(output_ids)
assert content == deepseek_r1_qwen_tokenizer.convert_tokens_to_ids(
content_ids = parser.extract_content_ids(output_ids)
assert content_ids == deepseek_r1_qwen_tokenizer.convert_tokens_to_ids(
deepseek_r1_qwen_tokenizer.tokenize(param_dict["content"])
)
else:
content = parser.extract_content_ids(output)
assert content == []
content_ids = parser.extract_content_ids(output)
assert content_ids == []
@@ -2,7 +2,7 @@
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
import pytest
from transformers import AutoTokenizer
from transformers import AutoTokenizer, PreTrainedTokenizerBase
from vllm.entrypoints.generate.base.protocol import DeltaMessage
from vllm.entrypoints.openai.chat_completion.protocol import ChatCompletionRequest
@@ -17,7 +17,7 @@ REASONING_MODEL_NAME = "deepseek-ai/DeepSeek-V3.1"
@pytest.fixture(scope="module")
def tokenizer():
def tokenizer() -> PreTrainedTokenizerBase:
return AutoTokenizer.from_pretrained(REASONING_MODEL_NAME)
@@ -2,7 +2,7 @@
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
import pytest
from transformers import AutoTokenizer
from transformers import AutoTokenizer, PreTrainedTokenizerBase
from tests.reasoning.utils import run_reasoning_extraction
from vllm.reasoning import ReasoningParser, ReasoningParserManager
@@ -13,7 +13,7 @@ REASONING_MODEL_NAME = "baidu/ERNIE-4.5-21B-A3B-Thinking"
@pytest.fixture(scope="module")
def ernie45_tokenizer():
def ernie45_tokenizer() -> PreTrainedTokenizerBase:
return AutoTokenizer.from_pretrained(REASONING_MODEL_NAME)
@@ -4,9 +4,11 @@
import copy
import pytest
from transformers import AutoTokenizer
from transformers import AutoTokenizer, PreTrainedTokenizerBase
from tests.reasoning.utils import run_reasoning_extraction
from vllm.parser.engine.adapters import ParserEngineReasoningAdapter
from vllm.parser.glm47_moe import Glm47MoeParser
from vllm.reasoning import ReasoningParser, ReasoningParserManager
parser_name = "glm45"
@@ -17,7 +19,7 @@ REASONING_MODEL_NAME = "zai-org/GLM-4.7"
@pytest.fixture(scope="module")
def glm45_tokenizer():
def glm45_tokenizer() -> PreTrainedTokenizerBase:
return AutoTokenizer.from_pretrained(REASONING_MODEL_NAME)
@@ -261,13 +263,20 @@ def glm53_style_tokenizer(glm45_tokenizer):
return tokenizer
def _glm_engine(parser: ReasoningParser) -> Glm47MoeParser:
assert isinstance(parser, ParserEngineReasoningAdapter)
engine = parser._parser_engine
assert isinstance(engine, Glm47MoeParser)
return engine
@pytest.mark.parametrize(
"disable_kwargs", [{"enable_thinking": False}, {"thinking": False}]
)
def test_glm53_template_forces_reasoning(disable_kwargs: dict, glm53_style_tokenizer):
parser_cls = ReasoningParserManager.get_reasoning_parser(parser_name)
parser = parser_cls(glm53_style_tokenizer, chat_template_kwargs=disable_kwargs)
assert parser._parser_engine.thinking_enabled
assert _glm_engine(parser).thinking_enabled
output = glm53_style_tokenizer.tokenize(GLM53_LEAK["output"])
output_tokens: list[str] = [
@@ -298,7 +307,7 @@ def test_glm47_template_honors_thinking_disable(glm45_tokenizer):
parser = ReasoningParserManager.get_reasoning_parser(parser_name)(
glm45_tokenizer, chat_template_kwargs={"enable_thinking": False}
)
assert not parser._parser_engine.thinking_enabled
assert not _glm_engine(parser).thinking_enabled
output = glm45_tokenizer.tokenize(GLM53_LEAK["output"])
output_tokens: list[str] = [
@@ -1,10 +1,11 @@
# SPDX-License-Identifier: Apache-2.0
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
from typing import TypedDict
from typing import TypedDict, cast
import pytest
import regex as re
from transformers import PreTrainedTokenizerBase
from tests.reasoning.utils import run_reasoning_extraction
from vllm.entrypoints.openai.chat_completion.protocol import (
@@ -52,8 +53,8 @@ class GraniteThinkingTokenizer:
@pytest.fixture
def tokenizer():
return GraniteThinkingTokenizer()
def tokenizer() -> PreTrainedTokenizerBase:
return cast(PreTrainedTokenizerBase, GraniteThinkingTokenizer())
# ── Basic reasoning extraction (non-streaming + streaming) ───────────
@@ -173,7 +174,7 @@ def tokenizer():
],
)
def test_granite_thinking_reasoning(
tokenizer: GraniteThinkingTokenizer,
tokenizer: PreTrainedTokenizerBase,
streaming: bool,
param_dict: ReasoningCase,
):
@@ -195,7 +196,7 @@ def test_granite_thinking_reasoning(
def test_granite_thinking_no_content_after_end_token(
tokenizer: GraniteThinkingTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
parser_cls = ReasoningParserManager.get_reasoning_parser(parser_name)
parser = parser_cls(tokenizer)
@@ -215,7 +216,7 @@ def test_granite_thinking_no_content_after_end_token(
@pytest.mark.parametrize("streaming", [False, True])
def test_granite_thinking_whitespace_only_content(
tokenizer: GraniteThinkingTokenizer,
tokenizer: PreTrainedTokenizerBase,
streaming: bool,
):
parser_cls = ReasoningParserManager.get_reasoning_parser(parser_name)
@@ -235,7 +236,7 @@ def test_granite_thinking_whitespace_only_content(
def test_granite_thinking_unterminated_think_block(
tokenizer: GraniteThinkingTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
parser_cls = ReasoningParserManager.get_reasoning_parser(parser_name)
parser = parser_cls(tokenizer)
@@ -260,7 +261,7 @@ def test_granite_thinking_unterminated_think_block(
def test_granite_thinking_disabled_moves_into_content(
tokenizer: GraniteThinkingTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
parser_cls = ReasoningParserManager.get_reasoning_parser(parser_name)
parser = parser_cls(tokenizer)
@@ -285,7 +286,7 @@ def test_granite_thinking_disabled_moves_into_content(
def test_granite_thinking_disabled_with_leading_newline(
tokenizer: GraniteThinkingTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
# With enable_thinking=False, model output goes through the swap
# path: content is initially None (all text classified as
@@ -316,7 +317,7 @@ def test_granite_thinking_disabled_with_leading_newline(
def test_granite_thinking_force_nonempty_content_moves_into_content(
tokenizer: GraniteThinkingTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
parser_cls = ReasoningParserManager.get_reasoning_parser(parser_name)
parser = parser_cls(tokenizer)
@@ -338,7 +339,7 @@ def test_granite_thinking_force_nonempty_content_moves_into_content(
def test_granite_thinking_force_nonempty_no_swap_when_newlines_only(
tokenizer: GraniteThinkingTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
# When </think> IS present and content is newlines-only, lstrip
# removes them but the swap should NOT fire — content was present,
@@ -363,7 +364,7 @@ def test_granite_thinking_force_nonempty_no_swap_when_newlines_only(
def test_granite_thinking_force_nonempty_swaps_when_content_absent(
tokenizer: GraniteThinkingTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
# When </think> IS present but content is truly absent (zero
# characters after </think>, e.g. max_tokens cut), swap fires.
@@ -387,7 +388,7 @@ def test_granite_thinking_force_nonempty_swaps_when_content_absent(
def test_granite_thinking_force_nonempty_keeps_real_content(
tokenizer: GraniteThinkingTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
parser_cls = ReasoningParserManager.get_reasoning_parser(parser_name)
parser = parser_cls(tokenizer)
@@ -412,7 +413,7 @@ def test_granite_thinking_force_nonempty_keeps_real_content(
def test_granite_thinking_keeps_truncated_reasoning(
tokenizer: GraniteThinkingTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
parser_cls = ReasoningParserManager.get_reasoning_parser(parser_name)
parser = parser_cls(tokenizer)
@@ -472,7 +473,7 @@ def _run_parse_delta(parser, tokenizer, text, request):
def test_granite_thinking_streaming_enable_thinking_false(
tokenizer: GraniteThinkingTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
# With enable_thinking=False, the parser (constructed without
# kwargs) starts in REASONING state. All text streams as reasoning
@@ -494,7 +495,7 @@ def test_granite_thinking_streaming_enable_thinking_false(
def test_granite_thinking_streaming_strips_leading_newline(
tokenizer: GraniteThinkingTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
request = ChatCompletionRequest(
model="test-model",
@@ -511,7 +512,7 @@ def test_granite_thinking_streaming_strips_leading_newline(
def test_granite_thinking_streaming_promotes_reasoning_to_content(
tokenizer: GraniteThinkingTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
request = ChatCompletionRequest(
model="test-model",
@@ -527,7 +528,7 @@ def test_granite_thinking_streaming_promotes_reasoning_to_content(
def test_granite_thinking_streaming_no_promotion_with_real_content(
tokenizer: GraniteThinkingTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
request = ChatCompletionRequest(
model="test-model",
@@ -548,7 +549,7 @@ def test_granite_thinking_streaming_no_promotion_with_real_content(
def test_granite_thinking_streaming_no_promotion_without_opt_in(
tokenizer: GraniteThinkingTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
request = ChatCompletionRequest(model="test-model", messages=[])
parser = _make_reasoning_parser(tokenizer)
@@ -564,7 +565,7 @@ def test_granite_thinking_streaming_no_promotion_without_opt_in(
@pytest.mark.parametrize("streaming", [False, True])
def test_granite_thinking_empty_think_block(
tokenizer: GraniteThinkingTokenizer,
tokenizer: PreTrainedTokenizerBase,
streaming: bool,
):
# <think></think>\nHello — empty reasoning, content after newline.
@@ -592,7 +593,7 @@ def test_granite_thinking_empty_think_block(
],
)
def test_granite_thinking_streaming_chunking_independent(
tokenizer: GraniteThinkingTokenizer,
tokenizer: PreTrainedTokenizerBase,
text: str,
expected_reasoning: str,
expected_content: str,
@@ -1,7 +1,7 @@
# SPDX-License-Identifier: Apache-2.0
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
import pytest
from transformers import AutoTokenizer
from transformers import AutoTokenizer, PreTrainedTokenizerBase
from tests.reasoning.utils import run_reasoning_extraction
from vllm.reasoning import ReasoningParser, ReasoningParserManager
@@ -15,7 +15,7 @@ REASONING_MODEL_NAME = "HCompany/Holo2-4B"
@pytest.fixture(scope="module")
def tokenizer():
def tokenizer() -> PreTrainedTokenizerBase:
return AutoTokenizer.from_pretrained(REASONING_MODEL_NAME)
@@ -3,6 +3,7 @@
import string
from collections.abc import Sequence
from typing import cast
import pytest
@@ -10,6 +11,7 @@ from vllm.entrypoints.openai.chat_completion.protocol import ChatCompletionReque
from vllm.parser.parser_manager import ParserManager
from vllm.reasoning import ReasoningParserManager
from vllm.reasoning.k2_horizon_reasoning_parser import K2HorizonReasoningParser
from vllm.tokenizers import TokenizerLike
pytestmark = pytest.mark.skip_global_cleanup
@@ -59,6 +61,10 @@ class K2Tokenizer:
return "".join(inverse_vocab[token_id] for token_id in ids)
def _k2_tokenizer() -> TokenizerLike:
return cast(TokenizerLike, K2Tokenizer())
def _request(**kwargs) -> ChatCompletionRequest:
return ChatCompletionRequest(
model="k2-horizon",
@@ -70,7 +76,7 @@ def _request(**kwargs) -> ChatCompletionRequest:
@pytest.mark.parametrize("effort", ["high", "medium", "low"])
def test_reasoning_effort_selects_tokens(effort: str):
parser = K2HorizonReasoningParser(
K2Tokenizer(),
_k2_tokenizer(),
chat_template_kwargs={"reasoning_effort": effort},
)
@@ -78,7 +84,7 @@ def test_reasoning_effort_selects_tokens(effort: str):
def test_reasoning_effort_precedence_and_default():
tokenizer = K2Tokenizer()
tokenizer = _k2_tokenizer()
request = _request(
reasoning_effort="medium",
chat_template_kwargs={"reasoning_effort": "low"},
@@ -103,13 +109,13 @@ def test_reasoning_effort_precedence_and_default():
def test_invalid_reasoning_effort_raises(effort: str | None):
with pytest.raises(ValueError, match="Unsupported reasoning_effort"):
K2HorizonReasoningParser(
K2Tokenizer(),
_k2_tokenizer(),
chat_template_kwargs={"reasoning_effort": effort},
)
def test_non_streaming_explicit_and_implicit_boundaries():
parser = K2HorizonReasoningParser(K2Tokenizer())
parser = K2HorizonReasoningParser(_k2_tokenizer())
request = _request()
assert parser.extract_reasoning("<ifm|think>plan</ifm|think>answer", request) == (
@@ -126,7 +132,7 @@ def test_non_streaming_explicit_and_implicit_boundaries():
@pytest.mark.parametrize("reasoning", ["plan", " ", "\n", " \n"])
def test_character_split_reasoning_stream(reasoning: str):
parser = K2HorizonReasoningParser(K2Tokenizer())
parser = K2HorizonReasoningParser(_k2_tokenizer())
reasoning_parts: list[str] = []
content_parts: list[str] = []
@@ -150,7 +156,7 @@ def test_character_split_reasoning_stream(reasoning: str):
def test_latest_boundary_controls_reasoning_state():
tokenizer = K2Tokenizer()
tokenizer = _k2_tokenizer()
parser = K2HorizonReasoningParser(tokenizer)
vocab = tokenizer.get_vocab()
@@ -159,7 +165,7 @@ def test_latest_boundary_controls_reasoning_state():
def test_composed_streaming_reasoning_to_tool_handoff():
tokenizer = K2Tokenizer()
tokenizer = _k2_tokenizer()
tools = [
{
"type": "function",
@@ -6,6 +6,7 @@ import pytest
from vllm.entrypoints.generate.base.protocol import DeltaMessage
from vllm.entrypoints.openai.chat_completion.protocol import ChatCompletionRequest
from vllm.parser.kimi_k2 import KimiK2Parser
from vllm.reasoning.kimi_k2_reasoning_parser import KimiK2ReasoningParser
from vllm.tokenizers import get_tokenizer
@@ -65,9 +66,13 @@ def test_extract_reasoning_tool_section_ends_reasoning(kimi_k2_tokenizer):
def test_streaming_reasoning_then_content(kimi_k2_tokenizer):
"""Token-by-token streaming: reasoning tokens then content after </think>."""
parser = KimiK2ReasoningParser(kimi_k2_tokenizer)
parser_engine = parser._parser_engine
assert isinstance(parser_engine, KimiK2Parser)
think_id = parser._parser_engine._start_token_id
end_think_id = parser._parser_engine._end_token_id
think_id = parser_engine._start_token_id
end_think_id = parser_engine._end_token_id
assert think_id is not None
assert end_think_id is not None
# Use a real token ID from the tokenizer for regular content
regular_id = kimi_k2_tokenizer.encode("hello", add_special_tokens=False)[0]
@@ -123,9 +128,13 @@ def test_streaming_reasoning_then_content(kimi_k2_tokenizer):
def test_streaming_tool_section_ends_reasoning(kimi_k2_tokenizer):
"""<|tool_calls_section_begin|> in delta ends reasoning during streaming."""
parser = KimiK2ReasoningParser(kimi_k2_tokenizer)
parser_engine = parser._parser_engine
assert isinstance(parser_engine, KimiK2Parser)
think_id = parser._parser_engine._start_token_id
tool_begin_id = parser._parser_engine._tool_section_start_token_id
think_id = parser_engine._start_token_id
tool_begin_id = parser_engine._tool_section_start_token_id
assert think_id is not None
assert tool_begin_id is not None
regular_id = kimi_k2_tokenizer.encode("hello", add_special_tokens=False)[0]
# Tool section token arrives — should transition from reasoning to content
@@ -1,6 +1,8 @@
# SPDX-License-Identifier: Apache-2.0
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
from typing import cast
import pytest
from vllm.entrypoints.generate.base.protocol import DeltaMessage
@@ -10,6 +12,7 @@ from vllm.entrypoints.openai.chat_completion.protocol import (
from vllm.parser.kimi_k3 import KimiK3Parser
from vllm.parser.parser_manager import ParserManager
from vllm.reasoning.kimi_k3_reasoning_parser import KimiK3ReasoningParser
from vllm.tokenizers import TokenizerLike
pytestmark = pytest.mark.skip_global_cleanup
@@ -25,10 +28,13 @@ RESPONSE_OPEN_IDS = [ord(ch) for ch in RESPONSE_OPEN]
class DummyTokenizer:
def __len__(self) -> int:
return 1
def get_vocab(self) -> dict[str, int]:
return {}
def encode(self, text: str, add_special_tokens: bool = False) -> list[int]:
def encode(self, text: str, *args, **kwargs) -> list[int]:
if text == THINK_OPEN:
return [1, 2, 3]
if text == THINK_CLOSE:
@@ -36,6 +42,10 @@ class DummyTokenizer:
return [ord(ch) for ch in text]
def _dummy_tokenizer() -> TokenizerLike:
return cast(TokenizerLike, DummyTokenizer())
class ReasoningOnlyParser(KimiK3Parser):
reasoning_parser_cls = KimiK3ReasoningParser
@@ -84,7 +94,7 @@ def test_extract_reasoning_with_generation_prefix_consumed():
def test_delegating_parser_strips_response_wrapper_without_tool_parser():
parser = ReasoningOnlyParser(DummyTokenizer())
parser = ReasoningOnlyParser(_dummy_tokenizer())
request = ChatCompletionRequest(model="test-model", messages=[])
reasoning, content, tool_calls = parser.parse(
@@ -165,7 +175,7 @@ def test_count_reasoning_tokens_is_zero_when_thinking_disabled():
def test_count_reasoning_tokens_through_delegating_parser():
parser = ReasoningOnlyParser(DummyTokenizer())
parser = ReasoningOnlyParser(_dummy_tokenizer())
assert parser.count_reasoning_tokens([*OPEN_IDS, 9, *CLOSE_IDS, 11]) == 1
@@ -253,7 +263,8 @@ def test_thinking_disabled_streams_content():
def test_delegating_parser_thinking_false_streams_response_content():
parser = ReasoningOnlyParser(
DummyTokenizer(), chat_template_kwargs={"thinking": False}
_dummy_tokenizer(),
chat_template_kwargs={"thinking": False},
)
request = ChatCompletionRequest(
model="test-model",
@@ -2,7 +2,7 @@
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
import pytest
from transformers import AutoTokenizer
from transformers import AutoTokenizer, PreTrainedTokenizerBase
from tests.reasoning.utils import run_reasoning_extraction
from vllm.reasoning import ReasoningParser, ReasoningParserManager
@@ -15,7 +15,7 @@ REASONING_MODEL_NAME = "MiniMaxAI/MiniMax-M2"
@pytest.fixture(scope="module")
def minimax_m2_tokenizer():
def minimax_m2_tokenizer() -> PreTrainedTokenizerBase:
return AutoTokenizer.from_pretrained(REASONING_MODEL_NAME)
@@ -2,7 +2,7 @@
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
import pytest
from transformers import AutoTokenizer
from transformers import AutoTokenizer, PreTrainedTokenizerBase
from tests.reasoning.utils import run_reasoning_extraction
from vllm.reasoning import ReasoningParser, ReasoningParserManager
@@ -15,7 +15,7 @@ REASONING_MODEL_NAME = "MiniMaxAI/MiniMax-M2"
@pytest.fixture(scope="module")
def minimax_m2_tokenizer():
def minimax_m2_tokenizer() -> PreTrainedTokenizerBase:
return AutoTokenizer.from_pretrained(REASONING_MODEL_NAME)
@@ -195,10 +195,10 @@ def test_reasoning(
# Test extract_content
if param_dict["content"] is not None:
content = parser.extract_content_ids(output_ids)
assert content == minimax_m2_tokenizer.convert_tokens_to_ids(
content_ids = parser.extract_content_ids(output_ids)
assert content_ids == minimax_m2_tokenizer.convert_tokens_to_ids(
minimax_m2_tokenizer.tokenize(param_dict["content"])
)
else:
content = parser.extract_content_ids(output)
assert content == []
content_ids = parser.extract_content_ids(output)
assert content_ids == []
@@ -1,10 +1,11 @@
# SPDX-License-Identifier: Apache-2.0
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
from typing import TypedDict
from typing import TypedDict, cast
import pytest
import regex as re
from transformers import PreTrainedTokenizerBase
from tests.reasoning.utils import run_reasoning_extraction
from vllm.entrypoints.openai.chat_completion.protocol import ChatCompletionRequest
@@ -48,8 +49,8 @@ class FakeNemotronTokenizer:
@pytest.fixture
def tokenizer():
return FakeNemotronTokenizer()
def tokenizer() -> PreTrainedTokenizerBase:
return cast(PreTrainedTokenizerBase, FakeNemotronTokenizer())
@pytest.mark.parametrize(
@@ -94,7 +95,7 @@ def tokenizer():
],
)
def test_nemotron_v3_reasoning(
tokenizer: FakeNemotronTokenizer,
tokenizer: PreTrainedTokenizerBase,
streaming: bool,
param_dict: ReasoningCase,
):
@@ -113,7 +114,7 @@ def test_nemotron_v3_reasoning(
def test_nemotron_v3_without_thinking_moves_into_content(
tokenizer: FakeNemotronTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
parser_cls = ReasoningParserManager.get_reasoning_parser(parser_name)
parser = parser_cls(tokenizer)
@@ -137,7 +138,7 @@ def test_nemotron_v3_without_thinking_moves_into_content(
def test_nemotron_v3_force_nonempty_content_moves_into_content(
tokenizer: FakeNemotronTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
parser_cls = ReasoningParserManager.get_reasoning_parser(parser_name)
parser = parser_cls(tokenizer)
@@ -159,7 +160,7 @@ def test_nemotron_v3_force_nonempty_content_moves_into_content(
def test_nemotron_v3_force_nonempty_keeps_real_content(
tokenizer: FakeNemotronTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
# When real content follows the closing tag nothing is promoted: the
# content after </think> is returned as-is and reasoning stays separate.
@@ -183,7 +184,7 @@ def test_nemotron_v3_force_nonempty_keeps_real_content(
def test_nemotron_v3_with_thinking_keeps_truncated_reasoning(
tokenizer: FakeNemotronTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
parser_cls = ReasoningParserManager.get_reasoning_parser(parser_name)
parser = parser_cls(tokenizer)
@@ -242,7 +243,7 @@ def _run_parse_delta(parser, tokenizer, text, request):
def test_nemotron_v3_streaming_promotes_reasoning_to_content(
tokenizer: FakeNemotronTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
# Model never closes <think>: reasoning streams normally AND is duplicated
# into content on the terminal delta.
@@ -260,7 +261,7 @@ def test_nemotron_v3_streaming_promotes_reasoning_to_content(
def test_nemotron_v3_streaming_no_promotion_with_real_content(
tokenizer: FakeNemotronTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
request = ChatCompletionRequest(
model="test-model",
@@ -279,7 +280,7 @@ def test_nemotron_v3_streaming_no_promotion_with_real_content(
def test_nemotron_v3_streaming_no_promotion_without_opt_in(
tokenizer: FakeNemotronTokenizer,
tokenizer: PreTrainedTokenizerBase,
):
# Without enable_thinking=False / force_nonempty_content the fallback must
# stay disabled: the response stays reasoning-only, content empty.
@@ -2,7 +2,7 @@
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
import pytest
from transformers import AutoTokenizer
from transformers import AutoTokenizer, PreTrainedTokenizerBase
from tests.reasoning.utils import (
StreamingReasoningReconstructor,
@@ -24,7 +24,7 @@ REASONING_MODEL_NAMES = [
@pytest.fixture(scope="module", params=REASONING_MODEL_NAMES)
def qwen3_tokenizer(request):
def qwen3_tokenizer(request) -> PreTrainedTokenizerBase:
return AutoTokenizer.from_pretrained(request.param)
@@ -4,7 +4,8 @@
import pytest
from tests.reasoning.utils import run_reasoning_extraction
from vllm.reasoning import ReasoningParser, ReasoningParserManager
from vllm.reasoning import ReasoningParserManager
from vllm.reasoning.step3p5_reasoning_parser import Step3p5ReasoningParser
from vllm.tokenizers import get_tokenizer
parser_name = "step3p5"
@@ -283,9 +284,8 @@ def test_reasoning(
output_tokens: list[str] = [
step3p5_tokenizer.convert_tokens_to_string([token]) for token in output
]
parser: ReasoningParser = ReasoningParserManager.get_reasoning_parser(parser_name)(
step3p5_tokenizer
)
parser = ReasoningParserManager.get_reasoning_parser(parser_name)(step3p5_tokenizer)
assert isinstance(parser, Step3p5ReasoningParser)
reasoning, content = run_reasoning_extraction(
parser, output_tokens, streaming=streaming
@@ -317,7 +317,7 @@ def test_reasoning(
# Test extract_content
if param_dict["content"] is not None:
content = parser.extract_content_ids(output_ids)
content_ids = parser.extract_content_ids(output_ids)
# Fixed expected token ids for specific test cases
test_id = (
request.node.callspec.id if hasattr(request.node, "callspec") else None
@@ -332,7 +332,7 @@ def test_reasoning(
expected_content_ids = step3p5_tokenizer.convert_tokens_to_ids(
step3p5_tokenizer.tokenize(param_dict["content"])
)
assert content == expected_content_ids
assert content_ids == expected_content_ids
else:
content = parser.extract_content_ids(output_ids)
assert content == []
content_ids = parser.extract_content_ids(output_ids)
assert content_ids == []
+7 -2
View File
@@ -1,6 +1,10 @@
# SPDX-License-Identifier: Apache-2.0
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
from typing import cast
from transformers import PreTrainedTokenizerBase
from vllm.entrypoints.generate.base.protocol import DeltaMessage
from vllm.entrypoints.openai.chat_completion.protocol import ChatCompletionRequest
from vllm.reasoning import ReasoningParser
@@ -102,10 +106,11 @@ def run_reasoning_extraction_streaming(
reconstructor = StreamingReasoningReconstructor()
previous_text = ""
previous_tokens: list[int] = []
tokenizer = cast(PreTrainedTokenizerBase, reasoning_parser.model_tokenizer)
for delta in model_deltas:
token_delta = [
reasoning_parser.vocab.get(token)
for token in reasoning_parser.model_tokenizer.tokenize(delta)
reasoning_parser.vocab[token]
for token in tokenizer.tokenize(delta)
if token in reasoning_parser.vocab
]
current_text = previous_text + delta