renderers 0.1.12.dev8__tar.gz → 0.1.12.dev10__tar.gz

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: renderers
-Version: 0.1.12.dev8
+Version: 0.1.12.dev10
 Summary: Chat template renderers — deterministic message-to-token conversion for LLM training
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -77,6 +77,14 @@ as self-contained: reasoning needs its own initial opener or channel header.
 Generation settings never supply missing parsing context. If the prompt supplied
 the opener, pass that prompt; `generate` does this automatically.
 
+Where vLLM 0.26's parser does the same, the format's atomic tool-call opener
+also ends reasoning that has no closing marker: Qwen3 / Qwen3-VL / Qwen3.5+,
+Prime-Qwen3, Nemotron-3, GLM, MiniMax-M2, DeepSeek-V4, Kimi-K2 / K2.5, Gemma 4,
+and Inkling. The call parses normally, and `bridge_to_next_turn` extends it
+without inserting a close. A closing marker later in the completion still wins:
+tool markup before it stays reasoning. Inkling ends thinking and tool segments
+with the same `<|end_message|>`, so there the first opener decides.
+
 For reasoning-first formats, only an initial `<think>` (after any assistant
 header) or reasoning already opened in the prompt starts reasoning. After its
 first closing marker, the rest is content. Later think markers remain literal

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/README.md

@@ -57,6 +57,14 @@ as self-contained: reasoning needs its own initial opener or channel header.
 Generation settings never supply missing parsing context. If the prompt supplied
 the opener, pass that prompt; `generate` does this automatically.
 
+Where vLLM 0.26's parser does the same, the format's atomic tool-call opener
+also ends reasoning that has no closing marker: Qwen3 / Qwen3-VL / Qwen3.5+,
+Prime-Qwen3, Nemotron-3, GLM, MiniMax-M2, DeepSeek-V4, Kimi-K2 / K2.5, Gemma 4,
+and Inkling. The call parses normally, and `bridge_to_next_turn` extends it
+without inserting a close. A closing marker later in the completion still wins:
+tool markup before it stays reasoning. Inkling ends thinking and tool segments
+with the same `<|end_message|>`, so there the first opener decides.
+
 For reasoning-first formats, only an initial `<think>` (after any assistant
 header) or reasoning already opened in the prompt starts reasoning. After its
 first closing marker, the rest is content. Later think markers remain literal

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/renderers/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.12.dev8'
-__version_tuple__ = version_tuple = (0, 1, 12, 'dev8')
+__version__ = version = '0.1.12.dev10'
+__version_tuple__ = version_tuple = (0, 1, 12, 'dev10')
 
 __commit_id__ = commit_id = None

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/renderers/deepseek_v4.py

@@ -826,6 +826,7 @@ class DeepSeekV4Renderer:
             prompt_ids=previous_prompt_ids,
             stop_ids=set(self.get_stop_token_ids()),
             tool_start_id=self._dsml,
+            tool_start_closes_reasoning=True,
             assistant_prefix="<｜Assistant｜>",
         )
         if boundary.is_open:

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/renderers/gemma4.py

@@ -1146,6 +1146,7 @@ class Gemma4Renderer:
             open_id=self._channel_start,
             close_id=self._channel_end,
             tool_start_id=self._tool_call_start,
+            tool_start_closes_reasoning=True,
         )
         if boundary.is_open:
             reasoning = (boundary.text or "").removeprefix("thought\n").strip()
@@ -1154,14 +1155,19 @@ class Gemma4Renderer:
                 reasoning_content=reasoning,
                 reasoning_complete=False,
             )
+
+        def thought_end(start: int) -> int:
+            """Index of the closer, else of a tool call that ended the thought."""
+            closer = self._channel_end
+            if self._channel_end not in ids[start:] and boundary.closed_by_tool:
+                closer = self._tool_call_start
+            return next((i for i in range(start, len(ids)) if ids[i] == closer), -1)
+
         reasoning: str | None = None
         content_ids: list[int] = []
         cursor = 0
         if ids and ids[0] == self._channel_start:
-            channel_end = next(
-                (i for i in range(1, len(ids)) if ids[i] == self._channel_end),
-                -1,
-            )
+            channel_end = thought_end(1)
             thought_start = 1
             if ids[thought_start : thought_start + len(self._thought_prefix)] == (
                 self._thought_prefix
@@ -1176,20 +1182,17 @@ class Gemma4Renderer:
                     reasoning_complete=False,
                 )
             reasoning = self._decode(ids[thought_start:channel_end]).strip()
-            cursor = channel_end + 1
+            cursor = channel_end + int(ids[channel_end] == self._channel_end)
         elif prefilled_thinking:
             # After a tool response, the canonical generation prompt already
             # ends with ``<|channel>thought\n``. The sampled completion therefore
             # starts with the thought body and contains only the closing
             # ``<channel|>`` marker. The supplied prompt identifies this
             # continuation, including when it truncates before the closer.
-            channel_end = next(
-                (i for i, token_id in enumerate(ids) if token_id == self._channel_end),
-                -1,
-            )
+            channel_end = thought_end(0)
             if channel_end != -1:
                 reasoning = self._decode(ids[:channel_end]).strip()
-                cursor = channel_end + 1
+                cursor = channel_end + int(ids[channel_end] == self._channel_end)
             else:
                 return ParsedResponse(
                     content="",
@@ -1294,6 +1297,7 @@ class Gemma4Renderer:
             prompt_ids=previous_prompt_ids,
             stop_ids=set(self.get_stop_token_ids()),
             tool_start_id=self._tool_call_start,
+            tool_start_closes_reasoning=True,
             initial_only=False,
             open_id=self._channel_start,
             close_id=self._channel_end,

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/renderers/glm45.py

@@ -334,6 +334,7 @@ class GLM45Renderer:
             prompt_ids=previous_prompt_ids,
             stop_ids=set(self.get_stop_token_ids()),
             tool_start_id=self._tool_call_tok,
+            tool_start_closes_reasoning=True,
             assistant_prefix="<|assistant|>",
         )
         if boundary.is_open:

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/renderers/glm5.py

@@ -377,6 +377,7 @@ class GLM5Renderer:
             prompt_ids=previous_prompt_ids,
             stop_ids=set(self.get_stop_token_ids()),
             tool_start_id=self._tool_call_tok,
+            tool_start_closes_reasoning=True,
             assistant_prefix="<|assistant|>",
         )
         if boundary.is_open:

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/renderers/inkling.py

@@ -831,7 +831,12 @@ class InklingRenderer:
         segment = tail[segment_start:]
         if segment and segment[0] == self._message_model:
             segment = segment[1:]
-        if segment and segment[0] == self._content_thinking:
+        # A tool-call opener ends an unclosed thinking segment (parse_inkling).
+        if (
+            segment
+            and segment[0] == self._content_thinking
+            and self._content_invoke_tool_json not in segment
+        ):
             if completion_end != len(previous_completion_ids):
                 return None
             previous_completion_ids = [*previous_completion_ids, self._end_message]

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/renderers/kimi_k2.py

@@ -378,6 +378,7 @@ class KimiK2Renderer:
             prompt_ids=previous_prompt_ids,
             stop_ids=set(self.get_stop_token_ids()),
             tool_start_id=self._tool_calls_section_begin,
+            tool_start_closes_reasoning=True,
             assistant_prefix="<|im_assistant|>assistant<|im_middle|>",
         )
         if boundary.is_open:

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/renderers/kimi_k25.py

@@ -47,6 +47,7 @@ from renderers.base import (
 )
 from renderers.configs import KimiK25RendererConfig
 from renderers.parsing import (
+    _find,
     _reasoning_end_token_index,
     parse_kimi_k2_section,
 )
@@ -461,6 +462,7 @@ def _parse_kimi_k2_response(
         tokenizer,
         ids,
         tool_start_id=tool_calls_section_begin_id,
+        tool_start_closes_reasoning=True,
         prefilled=prefilled_thinking,
         assistant_prefix="<|im_assistant|>assistant<|im_middle|>",
     )
@@ -474,9 +476,13 @@ def _parse_kimi_k2_response(
     # parse_qwen3). K2.5 renders </think> as text, so locate the boundary by
     # decoding; the section scan then starts past it. content_ids still begins
     # at 0, so the </think> text-split below recovers reasoning unchanged.
-    reasoning_end = (
-        _reasoning_end_token_index(tokenizer, ids) if boundary.text is not None else 0
-    )
+    # Without </think>, the section opener itself ends reasoning.
+    if boundary.closed_by_tool:
+        reasoning_end = _find(ids, tool_calls_section_begin_id)
+    elif boundary.text is not None:
+        reasoning_end = _reasoning_end_token_index(tokenizer, ids)
+    else:
+        reasoning_end = 0
 
     # Token-ID path — produces spans. Only run if every relevant special
     # token resolved at init (i.e. is in the tokenizer's vocab).
@@ -499,6 +505,8 @@ def _parse_kimi_k2_response(
             tool_call_end_id=tool_call_end_id,
             scan_start=reasoning_end,
         )
+        if boundary.closed_by_tool:
+            content_ids = content_ids[reasoning_end:]
         text = (
             tokenizer.decode(content_ids, skip_special_tokens=False)
             if content_ids
@@ -1030,6 +1038,7 @@ class KimiK25Renderer:
             prompt_ids=previous_prompt_ids,
             stop_ids=set(self.get_stop_token_ids()),
             tool_start_id=self._tool_calls_section_begin,
+            tool_start_closes_reasoning=True,
             assistant_prefix="<|im_assistant|>assistant<|im_middle|>",
         )
         if boundary.is_open:

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/renderers/minimax_m2.py

@@ -349,6 +349,7 @@ class MiniMaxM2Renderer:
             prompt_ids=previous_prompt_ids,
             stop_ids=set(self.get_stop_token_ids()),
             tool_start_id=self._tool_call_tok,
+            tool_start_closes_reasoning=True,
             assistant_prefix="]~b]ai\n",
         )
         if boundary.is_open:

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/renderers/nemotron3.py

@@ -568,6 +568,7 @@ class Nemotron3Renderer:
             prompt_ids=previous_prompt_ids,
             stop_ids=set(self.get_stop_token_ids()),
             tool_start_id=self._tool_call,
+            tool_start_closes_reasoning=True,
         )
         if boundary.is_open:
             if any(t in self.get_stop_token_ids() for t in previous_completion_ids):

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/renderers/parsing.py

@@ -214,6 +214,7 @@ def parse_qwen3(
         prefilled=prefilled_thinking,
         close_id=reasoning_end_id,
         tool_start_id=tool_call_id,
+        tool_start_closes_reasoning=True,
     )
     if boundary.is_open:
         return ParsedResponse(
@@ -222,12 +223,15 @@ def parse_qwen3(
 
     # Tool calls are parsed only after the initial reasoning region. An open
     # region returned above; a closed region can contain non-executable drafts.
-    reasoning_end = (
-        _find(ids, reasoning_end_id)
-        if reasoning_end_id is not None and boundary.text is not None
-        else -1
-    )
-    scan_start = reasoning_end + 1 if reasoning_end != -1 else 0
+    if boundary.closed_by_tool:
+        scan_start = _find(ids, tool_call_id)
+    else:
+        reasoning_end = (
+            _find(ids, reasoning_end_id)
+            if reasoning_end_id is not None and boundary.text is not None
+            else -1
+        )
+        scan_start = reasoning_end + 1 if reasoning_end != -1 else 0
 
     tc_start = _find(ids, tool_call_id, scan_start)
     tool_calls: list[ParsedToolCall] = []
@@ -294,7 +298,10 @@ def parse_qwen3(
     text = _decode(tokenizer, content_ids)
     # Extract reasoning from text (Qwen3 doesn't have <think> as special token)
     reasoning = None
-    if boundary.text is not None and "</think>" in text:
+    if boundary.closed_by_tool:
+        reasoning = boundary.text.strip("\n").strip()
+        text = _decode(tokenizer, content_ids[scan_start:])
+    elif boundary.text is not None and "</think>" in text:
         before, _, after = text.partition("</think>")
         reasoning = boundary.text.strip("\n").strip()
         text = after.strip("\n")
@@ -341,6 +348,7 @@ def parse_qwen35(
         open_id=think_id,
         close_id=think_end_id,
         tool_start_id=tool_call_id,
+        tool_start_closes_reasoning=True,
     )
     if boundary.is_open:
         return ParsedResponse(
@@ -351,10 +359,13 @@ def parse_qwen35(
     reasoning = None
     parse_offset = 0  # shift to map local indices back to stop-stripped ids
     think_end = _find(ids, think_end_id)
-    if boundary.text is not None and think_end != -1:
+    if boundary.closed_by_tool:
+        reasoning = boundary.text.strip()
+        parse_offset = _find(ids, tool_call_id)
+    elif boundary.text is not None and think_end != -1:
         reasoning = boundary.text.strip()
-        ids = ids[think_end + 1 :]
         parse_offset = think_end + 1
+    ids = ids[parse_offset:]
 
     tc_start = _find(ids, tool_call_id)
     tool_calls: list[ParsedToolCall] = []
@@ -501,6 +512,7 @@ def parse_glm(
         open_id=think_id,
         close_id=think_end_id,
         tool_start_id=tool_call_id,
+        tool_start_closes_reasoning=True,
         assistant_prefix="<|assistant|>",
     )
     if boundary.is_open:
@@ -511,10 +523,13 @@ def parse_glm(
     reasoning = None
     parse_offset = 0
     think_end = _find(ids, think_end_id)
-    if boundary.text is not None and think_end != -1:
+    if boundary.closed_by_tool:
+        reasoning = boundary.text.strip()
+        parse_offset = _find(ids, tool_call_id)
+    elif boundary.text is not None and think_end != -1:
         reasoning = boundary.text.strip()
-        ids = ids[think_end + 1 :]
         parse_offset = think_end + 1
+    ids = ids[parse_offset:]
 
     tc_start = _find(ids, tool_call_id)
     tool_calls: list[ParsedToolCall] = []
@@ -1236,6 +1251,7 @@ def parse_deepseek_v4(
         open_id=think_start_id,
         close_id=think_end_id,
         tool_start_id=dsml_id,
+        tool_start_closes_reasoning=True,
         assistant_prefix="<｜Assistant｜>",
     )
     if boundary.is_open:
@@ -1246,14 +1262,25 @@ def parse_deepseek_v4(
     reasoning: str | None = None
     content_offset = 0
     think_end = _find(ids, think_end_id)
-    if boundary.text is not None and think_end != -1:
+    if boundary.closed_by_tool:
+        content_offset = int(bool(ids) and ids[0] == think_start_id)
+    elif boundary.text is not None and think_end != -1:
         reasoning = boundary.text
         content_offset = think_end + 1
 
     content_ids = ids[content_offset:]
     decoded = _decode(tokenizer, content_ids)
-    section_marker = "\n\n<｜DSML｜tool_calls>"
-    section_pos = decoded.find(section_marker)
+    if boundary.closed_by_tool:
+        # Reasoning ran into DSML markup without </think>. The section opener
+        # is text around the atomic ｜DSML｜ token, so split before its tag
+        # and the canonical blank line.
+        prefix = _decode(tokenizer, content_ids[: _find(content_ids, dsml_id)])
+        section_pos = len(prefix.removesuffix("<"))
+        if decoded[:section_pos].endswith("\n\n"):
+            section_pos -= 2
+        reasoning = decoded[:section_pos]
+    else:
+        section_pos = decoded.find("\n\n<｜DSML｜tool_calls>")
     if section_pos == -1 or dsml_id not in content_ids:
         return ParsedResponse(
             content=decoded,
@@ -1261,7 +1288,7 @@ def parse_deepseek_v4(
             tool_calls=[],
         )
 
-    content = decoded[:section_pos]
+    content = "" if boundary.closed_by_tool else decoded[:section_pos]
     section_text = decoded[section_pos:]
     section_token_offset = content_offset + _decoded_char_to_token_index(
         tokenizer,
@@ -1431,6 +1458,7 @@ def parse_minimax(
         open_id=think_id,
         close_id=think_end_id,
         tool_start_id=tool_call_id,
+        tool_start_closes_reasoning=True,
         assistant_prefix="]~b]ai\n",
     )
     if boundary.is_open:
@@ -1442,10 +1470,13 @@ def parse_minimax(
     reasoning = None
     parse_offset = 0
     think_end = _find(ids, think_end_id)
-    if boundary.text is not None and think_end != -1:
+    if boundary.closed_by_tool:
+        reasoning = boundary.text.strip()
+        parse_offset = _find(ids, tool_call_id)
+    elif boundary.text is not None and think_end != -1:
         reasoning = boundary.text.strip()
-        ids = ids[think_end + 1 :]
         parse_offset = think_end + 1
+    ids = ids[parse_offset:]
 
     tc_start = _find(ids, tool_call_id)
     tool_calls: list[ParsedToolCall] = []
@@ -1609,6 +1640,7 @@ def parse_kimi_k2(
         ids,
         prefilled=prefilled_thinking,
         tool_start_id=tool_calls_section_begin_id,
+        tool_start_closes_reasoning=True,
         assistant_prefix="<|im_assistant|>assistant<|im_middle|>",
     )
     if boundary.is_open:
@@ -1616,6 +1648,12 @@ def parse_kimi_k2(
             content="", reasoning_content=boundary.text, reasoning_complete=False
         )
 
+    if boundary.closed_by_tool:
+        scan_start = _find(ids, tool_calls_section_begin_id)
+    elif boundary.text is not None:
+        scan_start = _reasoning_end_token_index(tokenizer, ids)
+    else:
+        scan_start = 0
     content_ids, tool_calls = parse_kimi_k2_section(
         tokenizer,
         ids,
@@ -1624,14 +1662,15 @@ def parse_kimi_k2(
         tool_call_begin_id=tool_call_begin_id,
         tool_call_argument_begin_id=tool_call_argument_begin_id,
         tool_call_end_id=tool_call_end_id,
-        scan_start=_reasoning_end_token_index(tokenizer, ids)
-        if boundary.text is not None
-        else 0,
+        scan_start=scan_start,
     )
 
     text = _decode(tokenizer, content_ids)
     reasoning: str | None = None
-    if boundary.text is not None and "</think>" in text:
+    if boundary.closed_by_tool:
+        reasoning = boundary.text.strip("\n").strip() or None
+        text = _decode(tokenizer, content_ids[scan_start:])
+    elif boundary.text is not None and "</think>" in text:
         before, _, after = text.partition("</think>")
         raw_think = boundary.text
         reasoning = raw_think.strip("\n").strip() or None
@@ -2015,6 +2054,27 @@ def parse_inkling(
             pass
         elif body[0] == content_thinking_id or (pos == 0 and prefilled_thinking):
             reasoning_ids = body[1:] if body[0] == content_thinking_id else body
+            # A tool-call opener ends the thinking segment (as in vLLM); the
+            # rest of the segment is the call's payload. Thinking and tool
+            # segments share <|end_message|>, so it cannot arbitrate here.
+            invoke = _find(reasoning_ids, invoke_json_id)
+            if invoke != -1:
+                reasoning_parts.append(_decode(tokenizer, reasoning_ids[:invoke]))
+                tool_calls.append(
+                    _build_inkling_tool_call(
+                        name="",
+                        payload=_decode(tokenizer, reasoning_ids[invoke + 1 :]),
+                        token_span=(
+                            seg_end - len(reasoning_ids) + invoke,
+                            seg_end + 1 if terminated else n,
+                        ),
+                        terminated=terminated,
+                    )
+                )
+                if not terminated:
+                    break
+                pos = em + 1
+                continue
             reasoning_parts.append(_decode(tokenizer, reasoning_ids))
             if not terminated:
                 return ParsedResponse(

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/renderers/prime_qwen3.py

@@ -660,6 +660,7 @@ class PrimeQwen3Renderer:
             prompt_ids=previous_prompt_ids,
             stop_ids=set(self.get_stop_token_ids()),
             tool_start_id=self._tool_call,
+            tool_start_closes_reasoning=True,
         )
         if boundary.is_open:
             if any(t in self.get_stop_token_ids() for t in previous_completion_ids):

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/renderers/qwen3.py

@@ -93,9 +93,16 @@ class Qwen3Renderer:
         return self._tokenizer.encode(text, add_special_tokens=False)
 
     @staticmethod
-    def _query_boundary_text(content) -> str:
+    def _content_text(content) -> str:
+        """Return the text parts of a message in a renderer-safe form.
+
+        Qwen3's native template is text-only, but text-only messages can also
+        use OpenAI-style content lists: ``[{"type": "text", "text": ...}]``.
+        Treat both representations identically instead of silently dropping
+        the message body.
+        """
         if isinstance(content, str):
-            return content.strip()
+            return content
         if isinstance(content, list):
             parts: list[str] = []
             for item in content:
@@ -103,9 +110,13 @@ class Qwen3Renderer:
                     parts.append(item)
                 elif isinstance(item, dict) and isinstance(item.get("text"), str):
                     parts.append(item["text"])
-            return "".join(parts).strip()
+            return "".join(parts)
         return ""
 
+    @staticmethod
+    def _query_boundary_text(content) -> str:
+        return Qwen3Renderer._content_text(content).strip()
+
     @staticmethod
     def _is_user_query_message(msg: Message) -> bool:
         if msg.get("role") != "user":
@@ -186,7 +197,7 @@ class Qwen3Renderer:
             # JSON as message body.
             segments: list[tuple[str, bool]] = [("system\n", False)]
             if first_is_system:
-                sys_content = messages[0].get("content") or ""
+                sys_content = self._content_text(messages[0].get("content"))
                 if sys_content:
                     segments.append((sys_content, True))
                 segments.append(("\n\n", False))
@@ -199,7 +210,7 @@ class Qwen3Renderer:
             emit_text("\n", sys_idx, is_sampled=False, is_content=False)
         elif first_is_system:
             emit_special(self._im_start, 0, is_sampled=False, is_content=False)
-            sys_content = messages[0].get("content") or ""
+            sys_content = self._content_text(messages[0].get("content"))
             sys_segments: list[tuple[str, bool]] = [("system\n", False)]
             if sys_content:
                 sys_segments.append((sys_content, True))
@@ -214,7 +225,7 @@ class Qwen3Renderer:
         num_messages = len(messages)
         for i, msg in enumerate(messages):
             role = msg["role"]
-            content = msg.get("content") if isinstance(msg.get("content"), str) else ""
+            content = self._content_text(msg.get("content"))
 
             if role == "system":
                 if i == 0:
@@ -334,6 +345,7 @@ class Qwen3Renderer:
             prompt_ids=previous_prompt_ids,
             stop_ids=set(self.get_stop_token_ids()),
             tool_start_id=self._tool_call,
+            tool_start_closes_reasoning=True,
         )
         if boundary.is_open:
             if any(t in self.get_stop_token_ids() for t in previous_completion_ids):
@@ -415,7 +427,7 @@ class Qwen3Renderer:
 
         for i, msg in enumerate(new_messages):
             role = msg.get("role")
-            content = msg.get("content") if isinstance(msg.get("content"), str) else ""
+            content = self._content_text(msg.get("content"))
             if role == "user":
                 emit_special(self._im_start, i)
                 user_segments: list[tuple[str, bool]] = [("user\n", False)]

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/renderers/qwen35.py

@@ -716,6 +716,7 @@ class Qwen35Renderer:
             prompt_ids=previous_prompt_ids,
             stop_ids=set(self.get_stop_token_ids()),
             tool_start_id=self._tool_call,
+            tool_start_closes_reasoning=True,
         )
         if boundary.is_open:
             if any(t in self.get_stop_token_ids() for t in previous_completion_ids):

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/renderers/qwen3_vl.py

@@ -706,6 +706,7 @@ class Qwen3VLRenderer:
             prompt_ids=previous_prompt_ids,
             stop_ids=set(self.get_stop_token_ids()),
             tool_start_id=self._tool_call,
+            tool_start_closes_reasoning=True,
         )
         if boundary.is_open:
             if any(t in self.get_stop_token_ids() for t in previous_completion_ids):

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/renderers/reasoning.py

@@ -5,10 +5,15 @@ from dataclasses import dataclass
 
 @dataclass(frozen=True)
 class ReasoningBoundary:
-    """Reasoning state and text; None means no reasoning region was opened."""
+    """Reasoning state and text; None means no reasoning region was opened.
+
+    ``closed_by_tool`` marks a region ended by a tool-call opener rather than
+    the format's close marker; the tool call then starts the content.
+    """
 
     is_open: bool
     text: str | None
+    closed_by_tool: bool = False
 
 
 def _decode(tokenizer, ids: list[int]) -> str:
@@ -87,6 +92,7 @@ def scan_reasoning(
     open_id: int | None = None,
     close_id: int | None = None,
     tool_start_id: int | None = None,
+    tool_start_closes_reasoning: bool = False,
     prompt_ids: list[int] | None = None,
     stop_ids: set[int] | frozenset[int] = frozenset(),
     open_marker: str = "<think>",
@@ -98,6 +104,10 @@ def scan_reasoning(
     body, or continue reasoning opened in the prompt. A first close permanently
     switches to content. Atomic delimiters match token IDs, not lookalike text.
     Explicit channel formats can opt into channel transitions instead.
+
+    ``tool_start_closes_reasoning`` lets an atomic tool-call opener end a
+    region that has no close marker, as vLLM's parsers do for these formats.
+    An explicit close still wins: tool markup before it stays reasoning.
     """
     if prompt_ids is not None:
         prefilled = prompt_ends_in_reasoning(
@@ -128,9 +138,16 @@ def scan_reasoning(
                 return ReasoningBoundary(False, None)
             start = int(explicit)
             close = next((i for i in range(start, len(ids)) if ids[i] == close_id), -1)
+            by_tool = False
+            if close == -1 and tool_start_closes_reasoning:
+                close = next(
+                    (i for i in range(start, len(ids)) if ids[i] == tool_start_id), -1
+                )
+                by_tool = close != -1
             return ReasoningBoundary(
                 close == -1,
                 _decode(tokenizer, ids[start : close if close != -1 else len(ids)]),
+                by_tool,
             )
         text = _decode(tokenizer, ids)
         explicit = text.startswith(open_marker)
@@ -138,8 +155,14 @@ def scan_reasoning(
             return ReasoningBoundary(False, None)
         start = len(open_marker) if explicit else 0
         close = text.find(close_marker, start)
+        by_tool = False
+        if close == -1 and tool_start_closes_reasoning:
+            tool = next((i for i, t in enumerate(ids) if t == tool_start_id), -1)
+            tool_pos = len(_decode(tokenizer, ids[:tool])) if tool != -1 else -1
+            if tool_pos >= start:
+                close, by_tool = tool_pos, True
         return ReasoningBoundary(
-            close == -1, text[start : close if close != -1 else len(text)]
+            close == -1, text[start : close if close != -1 else len(text)], by_tool
         )
 
     events: list[tuple[int, int, bool | None]]
@@ -176,11 +199,21 @@ def scan_reasoning(
 
     active = prefilled
     start = 0
+    by_tool = False
     closed_regions: list[tuple[int, int]] = []
-    for pos, after, opening in sorted(events):
+    events.sort()
+    for n, (pos, after, opening) in enumerate(events):
         if opening is None:
             if not active:
                 break
+            # While a region is active, its next close ends it; without one,
+            # the tool opener does.
+            if tool_start_closes_reasoning and all(
+                o is not False for _, _, o in events[n + 1 :]
+            ):
+                closed_regions.append((start, pos))
+                active = False
+                by_tool = True
             continue
         if opening:
             if not active:
@@ -196,4 +229,5 @@ def scan_reasoning(
     return ReasoningBoundary(
         is_open=active,
         text="".join(decode_region(a, b) for a, b in closed_regions),
+        closed_by_tool=by_tool,
     )

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/tests/test_bridge.py

@@ -205,6 +205,24 @@ def test_bridge_extension_includes_new_message_text(
     )
 
 
+def test_qwen3_renders_openai_text_content_parts(br_renderer, br_tokenizer, br_model):
+    """Text content lists must not become an empty user turn."""
+    if br_model not in {"Qwen/Qwen3-8B", "Qwen/Qwen3-4B"}:
+        pytest.skip(f"{br_model}: not a Qwen3 text renderer")
+
+    text = "CONTENT_LIST_SENTINEL_XYZ"
+    string_ids = br_renderer.render_ids(
+        [{"role": "user", "content": text}], add_generation_prompt=True
+    )
+    list_ids = br_renderer.render_ids(
+        [{"role": "user", "content": [{"type": "text", "text": text}]}],
+        add_generation_prompt=True,
+    )
+
+    assert list_ids == string_ids
+    assert text in br_tokenizer.decode(list_ids, skip_special_tokens=False)
+
+
 def test_bridge_declines_across_user_query_when_template_drops_thinking():
     """Qwen3's template drops a past block's thinking once a new user turn
     arrives. The resolved ``tool_cycle`` bridge policy therefore treats a

{renderers-0.1.12.dev8 → renderers-0.1.12.dev10}/tests/test_reasoning_boundaries.py

@@ -6,7 +6,7 @@ import pytest
 from parity import MODEL_CATALOG
 
 from renderers import create_renderer
-from renderers.base import load_tokenizer
+from renderers.base import ToolCallParseStatus, load_tokenizer
 from renderers.configs import config_from_name
 
 
@@ -157,15 +157,55 @@ def test_gemma_post_tool_prompt_supplies_reasoning_state():
     assert result.reasoning_complete is False
 
 
-@pytest.mark.parametrize(
-    "name", ["qwen3", "qwen3.5", "deepseek-r1", "kimi-k2", "kimi-k2.5", "laguna-xs-2.1"]
-)
+# Formats whose vLLM 0.26 parser ends unclosed reasoning at a tool-call opener,
+# with a well-formed call to ``danger``. The rest keep reasoning open.
+_QWEN_XML_CALL = "<tool_call>\n<function=danger>\n</function>\n</tool_call>"
+_GLM_CALL = "<tool_call>danger</tool_call>"
+_KIMI_CALL = "<|tool_calls_section_begin|><|tool_call_begin|>functions.danger:0<|tool_call_argument_begin|>{}<|tool_call_end|><|tool_calls_section_end|>"
+_TOOL_CALLS = {
+    "qwen3": '<tool_call>\n{"name": "danger", "arguments": {}}\n</tool_call>',
+    "qwen3-vl": '<tool_call>\n{"name": "danger", "arguments": {}}\n</tool_call>',
+    "qwen3.5": _QWEN_XML_CALL,
+    "qwen3.6": _QWEN_XML_CALL,
+    "qwen3.8": _QWEN_XML_CALL,
+    "prime-qwen3": _QWEN_XML_CALL,
+    "nemotron-3": _QWEN_XML_CALL,
+    "nemotron-3-ultra": _QWEN_XML_CALL,
+    "nemotron-3.5": _QWEN_XML_CALL,
+    "glm-4.5": _GLM_CALL,
+    "glm-5": _GLM_CALL,
+    "glm-5.1": _GLM_CALL,
+    "glm-5.3": _GLM_CALL,
+    "minimax-m2": '<minimax:tool_call>\n<invoke name="danger">\n</invoke>\n</minimax:tool_call>',
+    "deepseek-v4": '\n\n<｜DSML｜tool_calls>\n<｜DSML｜invoke name="danger">\n</｜DSML｜invoke>\n</｜DSML｜tool_calls>',
+    "kimi-k2": _KIMI_CALL,
+    "kimi-k2.5": _KIMI_CALL,
+    "gemma4": "<|tool_call>call:danger{}<tool_call|>",
+    "inkling": '<|content_invoke_tool_json|>{"name": "danger", "args": {}}<|end_message|>',
+}
+_STRICT_TOOL_OPENERS = {
+    "deepseek-r1",
+    "deepseek-v3",
+    "gpt-oss",
+    "hy3",
+    "laguna-m.1",
+    "laguna-s-2.1",
+    "laguna-xs-2.1",
+    "laguna-xs.2",
+}
+
+
+def test_every_reasoning_renderer_classifies_tool_openers():
+    reasoning_renderers = set(_CASES) - {"llama-3", "default"}
+    assert reasoning_renderers == set(_TOOL_CALLS) | _STRICT_TOOL_OPENERS
+    assert not set(_TOOL_CALLS) & _STRICT_TOOL_OPENERS
+
+
+@pytest.mark.parametrize("name", ["deepseek-r1", "laguna-xs-2.1"])
 def test_tool_drafts_in_unfinished_reasoning_are_not_executable(name):
     tok, renderer = _renderer(name)
     prompt, incomplete, _ = _thinking_stream(name, tok, renderer)
     draft = '<tool_call>{"name":"danger","arguments":{}}</tool_call>'
-    if name.startswith("kimi"):
-        draft = "<|tool_calls_section_begin|><|tool_call_begin|>functions.danger:0<|tool_call_argument_begin|>{}<|tool_call_end|><|tool_calls_section_end|>"
     if name == "deepseek-r1":
         draft = "<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>danger\n```json\n{}\n```<｜tool▁call▁end｜><｜tool▁calls▁end｜>"
     result = renderer.parse_response(
@@ -177,6 +217,74 @@ def test_tool_drafts_in_unfinished_reasoning_are_not_executable(name):
     assert result.reasoning_complete is False
 
 
+@pytest.mark.parametrize("name", sorted(_TOOL_CALLS))
+@pytest.mark.parametrize("stop", [False, True])
+def test_tool_opener_ends_unclosed_reasoning(name, stop):
+    tok, renderer = _renderer(name)
+    prompt, incomplete, _ = _thinking_stream(name, tok, renderer)
+    call = _encode(tok, _TOOL_CALLS[name])
+    sampled = incomplete + call + (renderer.get_stop_token_ids()[:1] if stop else [])
+    result = renderer.parse_response(sampled, prompt_ids=prompt)
+    assert result.content == ""
+    assert result.reasoning_content == "unfinished reasoning"
+    assert result.reasoning_complete is True
+    assert [(c.name, c.arguments, c.status) for c in result.tool_calls] == [
+        ("danger", {}, ToolCallParseStatus.OK)
+    ]
+    start, end = result.tool_calls[0].token_span
+    assert len(incomplete) <= start < end <= len(incomplete) + len(call)
+    assert "danger" in tok.decode(sampled[start:end], skip_special_tokens=False)
+
+
+@pytest.mark.parametrize("name", sorted(set(_TOOL_CALLS) - {"inkling"}))
+def test_explicit_reasoning_close_outranks_earlier_tool_opener(name):
+    # Inkling closes thinking and tool segments with the same <|end_message|>.
+    tok, renderer = _renderer(name)
+    prompt, incomplete, closed = _thinking_stream(name, tok, renderer)
+    draft = _encode(tok, _TOOL_CALLS[name])
+    result = renderer.parse_response(incomplete + draft + closed, prompt_ids=prompt)
+    assert result.content == "Answer"
+    assert "danger" in result.reasoning_content
+    assert result.tool_calls == []
+    assert result.reasoning_complete is True
+
+
+def test_inkling_prose_after_tool_opener_is_not_executable():
+    tok, renderer = _renderer("inkling")
+    prompt, incomplete, _ = _thinking_stream("inkling", tok, renderer)
+    draft = _encode(
+        tok, '<|content_invoke_tool_json|>{"name": "danger"} maybe not<|end_message|>'
+    )
+    result = renderer.parse_response(incomplete + draft, prompt_ids=prompt)
+    assert result.reasoning_content == "unfinished reasoning"
+    assert [c.status for c in result.tool_calls] == [ToolCallParseStatus.INVALID_JSON]
+
+
+@pytest.mark.parametrize("name", sorted(_TOOL_CALLS))
+@pytest.mark.parametrize("truncated", [False, True])
+def test_bridge_extends_tool_call_that_ended_reasoning(name, truncated):
+    tok, renderer = _renderer(name)
+    prompt, incomplete, _ = _thinking_stream(name, tok, renderer)
+    call = _encode(tok, _TOOL_CALLS[name])
+    sampled = incomplete + (
+        call[: len(call) // 2]
+        if truncated
+        else call + renderer.get_stop_token_ids()[:1]
+    )
+    bridge = renderer.bridge_to_next_turn(
+        prompt, sampled, [{"role": "user", "content": "Next question."}]
+    )
+    assert bridge is not None
+    prefix_len = len(prompt) + len(sampled)
+    assert bridge.token_ids[:prefix_len] == prompt + sampled
+    assert not any(bridge.sampled_mask[prefix_len:])
+    close_ids = {
+        "gemma4": lambda: [renderer._channel_end],
+        "inkling": lambda: [renderer._end_message],
+    }.get(name, lambda: _encode(tok, "</think>"))()
+    assert bridge.token_ids[prefix_len : prefix_len + len(close_ids)] != close_ids
+
+
 @pytest.mark.parametrize(
     "name", ["qwen3", "qwen3.5", "deepseek-r1", "kimi-k2.5", "laguna-xs-2.1", "gemma4"]
 )