[Bugfix] DeepSeek V4 reasoning parser: don't split DSML tool-call marker across streaming deltas

In thinking mode the V4 reasoning parser treats the DSML tool-call start
marker (<｜DSML｜tool_calls>) as an implicit end-of-reasoning when the model
omits </think>. Detection used text.find(marker), which only matches the
complete marker; when the marker arrives split across streaming deltas
("<｜DSML｜tool" then "_calls>"), the partial prefix is emitted as reasoning
and only "_calls>" reaches content, so the tool parser never sees the start
token. The tool call leaks as text and the agent loop ends with nothing to
dispatch. Relates to vllm-project#41132 and vllm-project#40801.

Hold back trailing bytes of current_text that form a partial prefix of an
implicit-end marker (via partial_tag_overlap) until a later delta resolves
them; on completion hand the whole marker (taken from current_text, so a
straddled marker stays intact) to content. Bookkeeping is delta-relative
(len(previous_text) - held_len), preserving the existing within-delta path.

Signed-off-by: tobymao <toby.mao@gmail.com>

Author: tobymao

tests/reasoning/test_deepseekv4_reasoning_parser.py

@@ -316,3 +316,49 @@ def test_single_end_token_delta_returns_none(parser):
         delta_token_ids=[END_TOKEN_ID],
     )
     assert out is None
+
+
+def test_implicit_end_marker_split_across_deltas(parser):
+    """Regression (vLLM #41132 / #40801): the DSML tool-call start marker can
+    arrive split across streaming deltas ("<｜DSML｜tool" then "_calls>"). The
+    partial prefix must not leak into reasoning, and the completed marker must
+    reach content whole so the tool parser sees its start token. Previously the
+    prefix was emitted as reasoning and only "_calls>" reached content, so the
+    tool call was lost and the agent loop ended with nothing to dispatch.
+    """
+    # 1. plain reasoning flows through
+    d1 = parser.extract_reasoning_streaming(
+        previous_text="",
+        current_text="thinking ",
+        delta_text="thinking ",
+        previous_token_ids=[],
+        current_token_ids=[300],
+        delta_token_ids=[300],
+    )
+    assert d1 is not None
+    assert d1.reasoning == "thinking "
+    assert d1.content is None
+
+    # 2. partial marker prefix -- held back, never emitted as reasoning
+    d2 = parser.extract_reasoning_streaming(
+        previous_text="thinking ",
+        current_text="thinking <｜DSML｜tool",
+        delta_text="<｜DSML｜tool",
+        previous_token_ids=[300],
+        current_token_ids=[300, 301],
+        delta_token_ids=[301],
+    )
+    assert "DSML" not in ((d2.reasoning if d2 else None) or "")
+
+    # 3. marker completes -- whole marker reaches content, nothing leaks
+    d3 = parser.extract_reasoning_streaming(
+        previous_text="thinking <｜DSML｜tool",
+        current_text="thinking " + DSML_MARKER,
+        delta_text="_calls>",
+        previous_token_ids=[300, 301],
+        current_token_ids=[300, 301, 302],
+        delta_token_ids=[302],
+    )
+    assert d3 is not None
+    assert (d3.reasoning or "") == ""
+    assert d3.content == DSML_MARKER

vllm/reasoning/deepseek_v4_reasoning_parser.py

@@ -58,6 +58,11 @@ def __init__(self, tokenizer: PreTrainedTokenizerBase, *args, **kwargs):
         # the rest of the stream is content and the orchestrator's
         # is_reasoning_end check must return True for every subsequent delta.
         self._implicit_end_seen: bool = False
+        # Length of the trailing partial implicit-end marker held back from the
+        # previous streaming delta (0 if none). With previous_text this lets us
+        # recover how much has already been emitted as reasoning, so a marker
+        # split across deltas is never half-emitted.
+        self._held_len: int = 0
 
     def _find_implicit_end_marker(self, text: str) -> tuple[str, int] | None:
         """Return ``(marker, index)`` of the earliest implicit end marker in
@@ -141,21 +146,40 @@ def extract_reasoning_streaming(
 
         marker_in_current = self._find_implicit_end_marker(current_text)
         if marker_in_current is None:
-            # No marker anywhere; parent's classification stands.
-            return ret
-
-        # First sighting of the implicit end marker.
+            # No COMPLETE marker yet, but the tail of current_text may be a
+            # partial implicit-end marker split across streaming deltas
+            # (e.g. "<｜DSML｜tool" before "_calls>" arrives). Emitting that
+            # partial prefix as reasoning would corrupt the marker so the tool
+            # parser never sees its start token. Hold those trailing bytes back
+            # until a later delta resolves them. Local import reuses the
+            # canonical helper without a module-load reasoning->tool_parsers
+            # import cycle.
+            from vllm.tool_parsers.utils import partial_tag_overlap
+
+            # Reasoning already emitted == previous_text minus the bytes held
+            # back at the end of the previous delta (delta-relative, so it does
+            # not assume earlier reasoning flowed through this method).
+            prev_emitted = len(previous_text) - self._held_len
+            overlap = max(
+                (partial_tag_overlap(current_text, m) for m in self.implicit_end_markers),
+                default=0,
+            )
+            self._held_len = overlap
+            sendable = len(current_text) - overlap
+            if sendable > prev_emitted:
+                return DeltaMessage(reasoning=current_text[prev_emitted:sendable])
+            # Everything new is a potential partial marker -- emit nothing.
+            return None
+
+        # First sighting of the COMPLETE implicit end marker. Emit reasoning
+        # between what we have already sent and the marker, then hand the whole
+        # marker (reconstructed from current_text, so a straddled marker stays
+        # intact) plus anything after it to content for the tool parser.
         self._implicit_end_seen = True
         _marker_str, marker_idx_current = marker_in_current
-        # Position within delta_text where the marker begins.
-        marker_idx_delta = marker_idx_current - len(previous_text)
-        if marker_idx_delta < 0:
-            # Marker straddles into previous_text but wasn't detected there
-            # (parent path didn't hit). Treat all of delta_text as content.
-            return DeltaMessage(content=delta_text)
-
-        reasoning_part = delta_text[:marker_idx_delta] or None
-        content_part = delta_text[marker_idx_delta:] or None
+        prev_emitted = len(previous_text) - self._held_len
+        reasoning_part = current_text[prev_emitted:marker_idx_current] or None
+        content_part = current_text[marker_idx_current:] or None
         if reasoning_part is None and content_part is None:
             return ret
         return DeltaMessage(reasoning=reasoning_part, content=content_part)