From 5544f8c18b9e9ae20e41e019d23d58260940f225 Mon Sep 17 00:00:00 2001 From: Fergus Date: Tue, 21 Apr 2026 19:31:27 +0100 Subject: [PATCH] [Performance] Add is_reasoning_end_streaming() override to GptOssReasoningParser (#35745) Signed-off-by: Fergus Signed-off-by: fergus barratt Co-authored-by: Chauncey --- .../reasoning/test_gptoss_reasoning_parser.py | 69 +++++++++++++++++++ vllm/reasoning/gptoss_reasoning_parser.py | 21 +++++- 2 files changed, 89 insertions(+), 1 deletion(-) diff --git a/tests/reasoning/test_gptoss_reasoning_parser.py b/tests/reasoning/test_gptoss_reasoning_parser.py index 3b1327acb6..a6f815b6ae 100644 --- a/tests/reasoning/test_gptoss_reasoning_parser.py +++ b/tests/reasoning/test_gptoss_reasoning_parser.py @@ -280,3 +280,72 @@ class TestGptOssStructuralTags: assert tag["content"]["type"] == "any_text" assert tag["end"] == "<|end|>" assert tag["begin"].startswith("<|channel|>") + + +@pytest.mark.parametrize( + "output, is_reasoning_end", + [(t["output"], t["is_reasoning_end"]) for t in TEST_CASES], +) +def test_gptoss_is_reasoning_end_streaming( + output, + is_reasoning_end, + gpt_oss_tokenizer, +): + """Streaming override must agree with is_reasoning_end for all cases.""" + tokens = gpt_oss_tokenizer.tokenize(output) + parser: ReasoningParser = GptOssReasoningParser(gpt_oss_tokenizer) + output_ids = gpt_oss_tokenizer.convert_tokens_to_ids(tokens) + delta_ids = output_ids[-1:] if output_ids else [] + actual = parser.is_reasoning_end_streaming(output_ids, delta_ids) + assert is_reasoning_end == actual + + +@pytest.mark.parametrize( + "output, is_reasoning_end", + [(t["output"], t["is_reasoning_end"]) for t in TEST_CASES], +) +def test_gptoss_is_reasoning_end_streaming_long_prefix( + output, + is_reasoning_end, + gpt_oss_tokenizer, +): + """Windowing must produce correct results even with a long prefix.""" + tokens = gpt_oss_tokenizer.tokenize(output) + parser: ReasoningParser = GptOssReasoningParser(gpt_oss_tokenizer) + output_ids = gpt_oss_tokenizer.convert_tokens_to_ids(tokens) + # Prepend 10k dummy reasoning tokens to simulate a long generation + long_prefix = [1] * 10_000 + padded_ids = long_prefix + list(output_ids) + delta_ids = output_ids[-1:] if output_ids else [] + actual = parser.is_reasoning_end_streaming(padded_ids, delta_ids) + assert is_reasoning_end == actual + + +@pytest.mark.parametrize( + "output, is_reasoning_end", + [(t["output"], t["is_reasoning_end"]) for t in TEST_CASES], +) +def test_gptoss_is_reasoning_end_streaming_large_delta( + output, + is_reasoning_end, + gpt_oss_tokenizer, +): + """Simulate speculative decoding where the entire test sequence arrives + as a single large delta appended after a long prefix. The window must + expand to cover delta_ids so the end pattern is never missed.""" + tokens = gpt_oss_tokenizer.tokenize(output) + parser: ReasoningParser = GptOssReasoningParser(gpt_oss_tokenizer) + output_ids = gpt_oss_tokenizer.convert_tokens_to_ids(tokens) + long_prefix = [1] * 10_000 + padded_ids = long_prefix + list(output_ids) + # delta_ids = the entire test sequence (as if accepted in one spec step) + delta_ids = list(output_ids) + actual = parser.is_reasoning_end_streaming(padded_ids, delta_ids) + assert is_reasoning_end == actual + + +def test_gptoss_is_reasoning_end_streaming_signature(gpt_oss_tokenizer): + """Verify the method is callable with the expected signature.""" + parser = GptOssReasoningParser(gpt_oss_tokenizer) + result = parser.is_reasoning_end_streaming([], []) + assert result is False diff --git a/vllm/reasoning/gptoss_reasoning_parser.py b/vllm/reasoning/gptoss_reasoning_parser.py index 89299d4b12..1ba933cca3 100644 --- a/vllm/reasoning/gptoss_reasoning_parser.py +++ b/vllm/reasoning/gptoss_reasoning_parser.py @@ -1,7 +1,7 @@ # SPDX-License-Identifier: Apache-2.0 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project import json -from collections.abc import Sequence +from collections.abc import Iterable, Sequence from typing import TYPE_CHECKING from transformers import PreTrainedTokenizerBase @@ -112,6 +112,25 @@ class GptOssReasoningParser(ReasoningParser): return True return False + def is_reasoning_end_streaming( + self, input_ids: Sequence[int], delta_ids: Iterable[int] + ) -> bool: + # The pattern window covers the end-of-reasoning marker itself. + # We add len(delta_ids) so that under speculative decoding (where + # a single step can accept many tokens) the entire accepted chunk + # is always inside the scan region. + delta_ids = tuple(delta_ids) + pattern_len = ( + len(self.reasoning_end_token_ids_prefix) + + self.reasoning_max_num_between_tokens + + len(self.reasoning_end_token_ids_suffix) + ) + window = pattern_len + len(delta_ids) + n = len(input_ids) + if n <= window: + return self.is_reasoning_end(input_ids) + return self.is_reasoning_end(input_ids[n - window :]) + def extract_content_ids(self, input_ids: list[int]) -> list[int]: _, content, _ = parse_chat_output(input_ids) if content is None: