renderers 0.1.8.dev32__tar.gz → 0.1.8.dev34__tar.gz

{renderers-0.1.8.dev32 → renderers-0.1.8.dev34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: renderers
-Version: 0.1.8.dev32
+Version: 0.1.8.dev34
 Summary: Chat template renderers — deterministic message-to-token conversion for LLM training
 License-Expression: Apache-2.0
 License-File: LICENSE

{renderers-0.1.8.dev32 → renderers-0.1.8.dev34}/examples/sglang/multiturn_generate_sglang.py

@@ -22,6 +22,7 @@ import json
 import os
 
 import sglang as sgl
+from renderers.configs import Qwen35RendererConfig
 from renderers.gpt_oss import GptOssRenderer
 from renderers.qwen35 import Qwen35Renderer
 from transformers import AutoTokenizer
@@ -52,7 +53,9 @@ TOOLS = [
 def make_renderer(model: str, enable_thinking: bool | None):
     tokenizer = AutoTokenizer.from_pretrained(model, trust_remote_code=False)
     if model.startswith("Qwen/Qwen3.5-"):
-        return Qwen35Renderer(tokenizer, enable_thinking=enable_thinking)
+        return Qwen35Renderer(
+            tokenizer, Qwen35RendererConfig(enable_thinking=enable_thinking)
+        )
     if model == "openai/gpt-oss-20b":
         return GptOssRenderer(tokenizer)
     raise ValueError(f"unsupported demo model: {model}")
@@ -62,8 +65,9 @@ def print_parsed(label: str, turn: str, parsed) -> None:
     print(f"\n[{label}] {turn}")
     if parsed.reasoning_content:
         print(f"reasoning: {parsed.reasoning_content[:240]}")
-    if parsed.tool_calls:
-        print(f"tool_calls: {json.dumps(parsed.tool_calls, ensure_ascii=False)}")
+    for tc in parsed.tool_calls:
+        # ``parse_response`` returns ``ParsedToolCall`` dataclasses, not dicts.
+        print(f"tool_call: {tc.name}({tc.arguments}) [{tc.status.value}]")
     if parsed.content:
         print(f"content: {parsed.content}")
 
@@ -141,21 +145,33 @@ def main() -> None:
         if parsed1.reasoning_content:
             assistant["reasoning_content"] = parsed1.reasoning_content
         if parsed1.tool_calls:
-            assistant["tool_calls"] = parsed1.tool_calls
+            # Convert the parsed dataclasses back to OpenAI-format tool_calls.
+            assistant["tool_calls"] = [
+                {
+                    "id": tc.id or f"call_{idx}",
+                    "type": "function",
+                    "function": {
+                        "name": tc.name,
+                        "arguments": tc.arguments
+                        if isinstance(tc.arguments, str)
+                        else json.dumps(tc.arguments),
+                    },
+                }
+                for idx, tc in enumerate(parsed1.tool_calls)
+            ]
         messages.append(assistant)
 
         if parsed1.tool_calls:
             new_messages = []
             for idx, tool_call in enumerate(parsed1.tool_calls):
-                fn = tool_call.get("function") or tool_call
-                tool_args = fn.get("arguments") or {}
+                tool_args = tool_call.arguments or {}
                 if isinstance(tool_args, str):
                     tool_args = json.loads(tool_args)
                 new_messages.append(
                     {
                         "role": "tool",
-                        "tool_call_id": tool_call.get("id", f"call_{idx}"),
-                        "name": fn.get("name", "multiply"),
+                        "tool_call_id": tool_call.id or f"call_{idx}",
+                        "name": tool_call.name or "multiply",
                         "content": json.dumps(
                             {"result": int(tool_args["a"]) * int(tool_args["b"])}
                         ),
@@ -167,11 +183,14 @@ def main() -> None:
             ]
 
         # Turn 2: bridge extends prompt_ids + completion1 exactly.
-        bridged_ids = renderer.bridge_to_next_turn(
+        # ``bridge_to_next_turn`` returns a ``RenderedTokens`` (or None); the
+        # extended id stream is on ``.token_ids``.
+        bridged = renderer.bridge_to_next_turn(
             prompt_ids, completion1, new_messages, tools=TOOLS
         )
-        if bridged_ids is None:
+        if bridged is None:
             raise RuntimeError("bridge_to_next_turn returned None")
+        bridged_ids = bridged.token_ids
         assert bridged_ids[: len(prompt_ids) + len(completion1)] == (
             prompt_ids + completion1
         )

{renderers-0.1.8.dev32 → renderers-0.1.8.dev34}/examples/sglang/online_multiturn_sglang.py

@@ -44,6 +44,7 @@ from typing import Any
 
 import httpx
 from renderers.base import Renderer
+from renderers.configs import Qwen35RendererConfig
 from renderers.gpt_oss import GptOssRenderer
 from renderers.qwen35 import Qwen35Renderer
 from transformers import AutoTokenizer
@@ -71,7 +72,9 @@ TOOLS = [
 def make_renderer(model: str, enable_thinking: bool | None) -> Renderer:
     tokenizer = AutoTokenizer.from_pretrained(model, trust_remote_code=False)
     if model.startswith("Qwen/Qwen3.5-"):
-        return Qwen35Renderer(tokenizer, enable_thinking=enable_thinking)
+        return Qwen35Renderer(
+            tokenizer, Qwen35RendererConfig(enable_thinking=enable_thinking)
+        )
     if model == "openai/gpt-oss-20b":
         return GptOssRenderer(tokenizer)
     raise ValueError(f"unsupported demo model: {model}")
@@ -116,8 +119,9 @@ def print_parsed(label: str, turn: str, parsed) -> None:
     print(f"\n[{label}] {turn}")
     if parsed.reasoning_content:
         print(f"reasoning: {parsed.reasoning_content[:240]}")
-    if parsed.tool_calls:
-        print(f"tool_calls: {json.dumps(parsed.tool_calls, ensure_ascii=False)}")
+    for tc in parsed.tool_calls:
+        # ``parse_response`` returns ``ParsedToolCall`` dataclasses, not dicts.
+        print(f"tool_call: {tc.name}({tc.arguments}) [{tc.status.value}]")
     if parsed.content:
         print(f"content: {parsed.content}")
 
@@ -164,21 +168,33 @@ async def run_one(
     if parsed1.reasoning_content:
         assistant["reasoning_content"] = parsed1.reasoning_content
     if parsed1.tool_calls:
-        assistant["tool_calls"] = parsed1.tool_calls
+        # Convert the parsed dataclasses back to OpenAI-format tool_calls.
+        assistant["tool_calls"] = [
+            {
+                "id": tc.id or f"call_{idx}",
+                "type": "function",
+                "function": {
+                    "name": tc.name,
+                    "arguments": tc.arguments
+                    if isinstance(tc.arguments, str)
+                    else json.dumps(tc.arguments),
+                },
+            }
+            for idx, tc in enumerate(parsed1.tool_calls)
+        ]
     messages.append(assistant)
 
     if parsed1.tool_calls:
         new_messages: list[dict[str, Any]] = []
         for idx, tool_call in enumerate(parsed1.tool_calls):
-            fn = tool_call.get("function") or tool_call
-            tool_args = fn.get("arguments") or {}
+            tool_args = tool_call.arguments or {}
             if isinstance(tool_args, str):
                 tool_args = json.loads(tool_args)
             new_messages.append(
                 {
                     "role": "tool",
-                    "tool_call_id": tool_call.get("id", f"call_{idx}"),
-                    "name": fn.get("name", "multiply"),
+                    "tool_call_id": tool_call.id or f"call_{idx}",
+                    "name": tool_call.name or "multiply",
                     "content": json.dumps(
                         {"result": int(tool_args["a"]) * int(tool_args["b"])}
                     ),
@@ -190,11 +206,14 @@ async def run_one(
         ]
 
     # Turn 2: bridge extends prompt_ids + completion1 exactly.
-    bridged_ids = renderer.bridge_to_next_turn(
+    # ``bridge_to_next_turn`` returns a ``RenderedTokens`` (or None); the
+    # extended id stream is on ``.token_ids``.
+    bridged = renderer.bridge_to_next_turn(
         prompt_ids, completion1, new_messages, tools=TOOLS
     )
-    if bridged_ids is None:
+    if bridged is None:
         raise RuntimeError("bridge_to_next_turn returned None")
+    bridged_ids = bridged.token_ids
     assert bridged_ids[: len(prompt_ids) + len(completion1)] == (
         prompt_ids + completion1
     )

{renderers-0.1.8.dev32 → renderers-0.1.8.dev34}/examples/tinker/multiturn_generate_tinker.py

@@ -22,6 +22,7 @@ import json
 import os
 
 import tinker
+from renderers.configs import Qwen35RendererConfig
 from renderers.gpt_oss import GptOssRenderer
 from renderers.qwen35 import Qwen35Renderer
 from tinker import types
@@ -53,7 +54,9 @@ TOOLS = [
 def make_renderer(model: str, enable_thinking: bool | None):
     tokenizer = AutoTokenizer.from_pretrained(model, trust_remote_code=False)
     if model.startswith("Qwen/Qwen3.5-"):
-        return Qwen35Renderer(tokenizer, enable_thinking=enable_thinking)
+        return Qwen35Renderer(
+            tokenizer, Qwen35RendererConfig(enable_thinking=enable_thinking)
+        )
     if model == "openai/gpt-oss-20b":
         return GptOssRenderer(tokenizer)
     raise ValueError(f"unsupported demo model: {model}")
@@ -63,8 +66,9 @@ def print_parsed(label: str, turn: str, parsed) -> None:
     print(f"\n[{label}] {turn}")
     if parsed.reasoning_content:
         print(f"reasoning: {parsed.reasoning_content[:240]}")
-    if parsed.tool_calls:
-        print(f"tool_calls: {json.dumps(parsed.tool_calls, ensure_ascii=False)}")
+    for tc in parsed.tool_calls:
+        # ``parse_response`` returns ``ParsedToolCall`` dataclasses, not dicts.
+        print(f"tool_call: {tc.name}({tc.arguments}) [{tc.status.value}]")
     if parsed.content:
         print(f"content: {parsed.content}")
 
@@ -131,21 +135,33 @@ async def main() -> None:
         if parsed1.reasoning_content:
             assistant["reasoning_content"] = parsed1.reasoning_content
         if parsed1.tool_calls:
-            assistant["tool_calls"] = parsed1.tool_calls
+            # Convert the parsed dataclasses back to OpenAI-format tool_calls.
+            assistant["tool_calls"] = [
+                {
+                    "id": tc.id or f"call_{idx}",
+                    "type": "function",
+                    "function": {
+                        "name": tc.name,
+                        "arguments": tc.arguments
+                        if isinstance(tc.arguments, str)
+                        else json.dumps(tc.arguments),
+                    },
+                }
+                for idx, tc in enumerate(parsed1.tool_calls)
+            ]
         messages.append(assistant)
 
         if parsed1.tool_calls:
             new_messages = []
             for idx, tool_call in enumerate(parsed1.tool_calls):
-                fn = tool_call.get("function") or tool_call
-                tool_args = fn.get("arguments") or {}
+                tool_args = tool_call.arguments or {}
                 if isinstance(tool_args, str):
                     tool_args = json.loads(tool_args)
                 new_messages.append(
                     {
                         "role": "tool",
-                        "tool_call_id": tool_call.get("id", f"call_{idx}"),
-                        "name": fn.get("name", "multiply"),
+                        "tool_call_id": tool_call.id or f"call_{idx}",
+                        "name": tool_call.name or "multiply",
                         "content": json.dumps(
                             {"result": int(tool_args["a"]) * int(tool_args["b"])}
                         ),
@@ -157,11 +173,14 @@ async def main() -> None:
             ]
 
         # Turn 2: bridge extends prompt_ids + completion1 exactly.
-        bridged_ids = renderer.bridge_to_next_turn(
+        # ``bridge_to_next_turn`` returns a ``RenderedTokens`` (or None); the
+        # extended id stream is on ``.token_ids``.
+        bridged = renderer.bridge_to_next_turn(
             prompt_ids, completion1, new_messages, tools=TOOLS
         )
-        if bridged_ids is None:
+        if bridged is None:
             raise RuntimeError("bridge_to_next_turn returned None")
+        bridged_ids = bridged.token_ids
         assert bridged_ids[: len(prompt_ids) + len(completion1)] == (
             prompt_ids + completion1
         )

{renderers-0.1.8.dev32 → renderers-0.1.8.dev34}/examples/transformers/multiturn_generate_transformers.py

@@ -26,6 +26,7 @@ import os
 import torch
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
+from renderers.configs import Qwen35RendererConfig
 from renderers.gpt_oss import GptOssRenderer
 from renderers.qwen35 import Qwen35Renderer
 
@@ -55,7 +56,8 @@ TOOLS = [
 def make_renderer(model: str, enable_thinking: bool | None):
     tokenizer = AutoTokenizer.from_pretrained(model, trust_remote_code=False)
     if model.startswith("Qwen/Qwen3.5-"):
-        return Qwen35Renderer(tokenizer, enable_thinking=enable_thinking), tokenizer
+        config = Qwen35RendererConfig(enable_thinking=enable_thinking)
+        return Qwen35Renderer(tokenizer, config), tokenizer
     if model == "openai/gpt-oss-20b":
         return GptOssRenderer(tokenizer), tokenizer
     raise ValueError(f"unsupported demo model: {model}")
@@ -65,8 +67,9 @@ def print_parsed(label: str, turn: str, parsed) -> None:
     print(f"\n[{label}] {turn}")
     if parsed.reasoning_content:
         print(f"reasoning: {parsed.reasoning_content[:240]}")
-    if parsed.tool_calls:
-        print(f"tool_calls: {json.dumps(parsed.tool_calls, ensure_ascii=False)}")
+    for tc in parsed.tool_calls:
+        # ``parse_response`` returns ``ParsedToolCall`` dataclasses, not dicts.
+        print(f"tool_call: {tc.name}({tc.arguments}) [{tc.status.value}]")
     if parsed.content:
         print(f"content: {parsed.content}")
 
@@ -139,21 +142,33 @@ def main() -> None:
         if parsed1.reasoning_content:
             assistant["reasoning_content"] = parsed1.reasoning_content
         if parsed1.tool_calls:
-            assistant["tool_calls"] = parsed1.tool_calls
+            # Convert the parsed dataclasses back to OpenAI-format tool_calls.
+            assistant["tool_calls"] = [
+                {
+                    "id": tc.id or f"call_{idx}",
+                    "type": "function",
+                    "function": {
+                        "name": tc.name,
+                        "arguments": tc.arguments
+                        if isinstance(tc.arguments, str)
+                        else json.dumps(tc.arguments),
+                    },
+                }
+                for idx, tc in enumerate(parsed1.tool_calls)
+            ]
         messages.append(assistant)
 
         if parsed1.tool_calls:
             new_messages = []
             for idx, tool_call in enumerate(parsed1.tool_calls):
-                fn = tool_call.get("function") or tool_call
-                tool_args = fn.get("arguments") or {}
+                tool_args = tool_call.arguments or {}
                 if isinstance(tool_args, str):
                     tool_args = json.loads(tool_args)
                 new_messages.append(
                     {
                         "role": "tool",
-                        "tool_call_id": tool_call.get("id", f"call_{idx}"),
-                        "name": fn.get("name", "multiply"),
+                        "tool_call_id": tool_call.id or f"call_{idx}",
+                        "name": tool_call.name or "multiply",
                         "content": json.dumps(
                             {"result": int(tool_args["a"]) * int(tool_args["b"])}
                         ),
@@ -165,11 +180,14 @@ def main() -> None:
             ]
 
         # Turn 2: bridge extends prompt_ids + completion1 exactly.
-        bridged_ids = renderer.bridge_to_next_turn(
+        # ``bridge_to_next_turn`` returns a ``RenderedTokens`` (or None); the
+        # extended id stream is on ``.token_ids``.
+        bridged = renderer.bridge_to_next_turn(
             prompt_ids, completion1, new_messages, tools=TOOLS
         )
-        if bridged_ids is None:
+        if bridged is None:
             raise RuntimeError("bridge_to_next_turn returned None")
+        bridged_ids = bridged.token_ids
         assert bridged_ids[: len(prompt_ids) + len(completion1)] == (
             prompt_ids + completion1
         )

{renderers-0.1.8.dev32 → renderers-0.1.8.dev34}/examples/vllm/multiturn_generate_vllm.py

@@ -21,6 +21,7 @@ import gc
 import json
 import os
 
+from renderers.configs import Qwen35RendererConfig
 from renderers.gpt_oss import GptOssRenderer
 from renderers.qwen35 import Qwen35Renderer
 from transformers import AutoTokenizer
@@ -52,7 +53,9 @@ TOOLS = [
 def make_renderer(model: str, enable_thinking: bool | None):
     tokenizer = AutoTokenizer.from_pretrained(model, trust_remote_code=False)
     if model.startswith("Qwen/Qwen3.5-"):
-        return Qwen35Renderer(tokenizer, enable_thinking=enable_thinking)
+        return Qwen35Renderer(
+            tokenizer, Qwen35RendererConfig(enable_thinking=enable_thinking)
+        )
     if model == "openai/gpt-oss-20b":
         return GptOssRenderer(tokenizer)
     raise ValueError(f"unsupported demo model: {model}")
@@ -62,8 +65,9 @@ def print_parsed(label: str, turn: str, parsed) -> None:
     print(f"\n[{label}] {turn}")
     if parsed.reasoning_content:
         print(f"reasoning: {parsed.reasoning_content[:240]}")
-    if parsed.tool_calls:
-        print(f"tool_calls: {json.dumps(parsed.tool_calls, ensure_ascii=False)}")
+    for tc in parsed.tool_calls:
+        # ``parse_response`` returns ``ParsedToolCall`` dataclasses, not dicts.
+        print(f"tool_call: {tc.name}({tc.arguments}) [{tc.status.value}]")
     if parsed.content:
         print(f"content: {parsed.content}")
 
@@ -134,21 +138,33 @@ def main() -> None:
         if parsed1.reasoning_content:
             assistant["reasoning_content"] = parsed1.reasoning_content
         if parsed1.tool_calls:
-            assistant["tool_calls"] = parsed1.tool_calls
+            # Convert the parsed dataclasses back to OpenAI-format tool_calls.
+            assistant["tool_calls"] = [
+                {
+                    "id": tc.id or f"call_{idx}",
+                    "type": "function",
+                    "function": {
+                        "name": tc.name,
+                        "arguments": tc.arguments
+                        if isinstance(tc.arguments, str)
+                        else json.dumps(tc.arguments),
+                    },
+                }
+                for idx, tc in enumerate(parsed1.tool_calls)
+            ]
         messages.append(assistant)
 
         if parsed1.tool_calls:
             new_messages = []
             for idx, tool_call in enumerate(parsed1.tool_calls):
-                fn = tool_call.get("function") or tool_call
-                tool_args = fn.get("arguments") or {}
+                tool_args = tool_call.arguments or {}
                 if isinstance(tool_args, str):
                     tool_args = json.loads(tool_args)
                 new_messages.append(
                     {
                         "role": "tool",
-                        "tool_call_id": tool_call.get("id", f"call_{idx}"),
-                        "name": fn.get("name", "multiply"),
+                        "tool_call_id": tool_call.id or f"call_{idx}",
+                        "name": tool_call.name or "multiply",
                         "content": json.dumps(
                             {"result": int(tool_args["a"]) * int(tool_args["b"])}
                         ),
@@ -160,11 +176,14 @@ def main() -> None:
             ]
 
         # Turn 2: bridge extends prompt_ids + completion1 exactly.
-        bridged_ids = renderer.bridge_to_next_turn(
+        # ``bridge_to_next_turn`` returns a ``RenderedTokens`` (or None); the
+        # extended id stream is on ``.token_ids``.
+        bridged = renderer.bridge_to_next_turn(
             prompt_ids, completion1, new_messages, tools=TOOLS
         )
-        if bridged_ids is None:
+        if bridged is None:
             raise RuntimeError("bridge_to_next_turn returned None")
+        bridged_ids = bridged.token_ids
         assert bridged_ids[: len(prompt_ids) + len(completion1)] == (
             prompt_ids + completion1
         )

{renderers-0.1.8.dev32 → renderers-0.1.8.dev34}/renderers/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.8.dev32'
-__version_tuple__ = version_tuple = (0, 1, 8, 'dev32')
+__version__ = version = '0.1.8.dev34'
+__version_tuple__ = version_tuple = (0, 1, 8, 'dev34')
 
 __commit_id__ = commit_id = None

{renderers-0.1.8.dev32 → renderers-0.1.8.dev34}/renderers/base.py

@@ -911,8 +911,8 @@ MODEL_RENDERER_MAP: dict[str, str] = {
     # ``enable_thinking=true`` (open ``<think>\n`` at the gen prompt);
     # the smaller 0.8B / 2B variants flip the polarity (default
     # ``enable_thinking=false``, empty ``<think>\n\n</think>\n\n``).
-    # ``Qwen35Renderer`` auto-detects polarity from the tokenizer's
-    # chat_template at construction, so all seven sizes are
+    # ``Qwen35Renderer`` hard-codes this polarity per model
+    # (``_ENABLE_THINKING_DEFAULTS``), so all seven sizes are
     # token-for-token parity-tested against their own
     # ``apply_chat_template`` — including with
     # ``add_generation_prompt=True``.

{renderers-0.1.8.dev32 → renderers-0.1.8.dev34}/renderers/qwen35.py

@@ -66,39 +66,44 @@ _TOOLS_INSTRUCTIONS = (
 )
 
 
-def _detect_enable_thinking_default(tokenizer: PreTrainedTokenizer) -> bool:
-    """Probe the tokenizer's chat template to learn its ``enable_thinking``
-    default polarity at the generation-prompt boundary.
-
-    The Qwen3.5 family ships two template variants that differ only in the
-    polarity of the gated branch:
-
-    * Big sizes (4B / 9B / 35B-A3B / 122B-A10B / 397B-A17B) emit an open
-      ``<think>\\n`` by default and the empty ``<think>\\n\\n</think>\\n\\n``
-      block when ``enable_thinking`` is explicitly false.
-    * Small sizes (0.8B / 2B) flip the polarity — they emit the empty
-      block by default and the open ``<think>\\n`` only when
-      ``enable_thinking`` is explicitly true.
-
-    A one-shot ``apply_chat_template`` call with no flag and a minimal
-    user message reveals which variant is in use: the empty-block tail
-    ends with ``</think>``, the open-think tail does not. Failing the
-    probe (no chat_template, exotic config) falls back to the big-model
-    default of True, which matches every entry in
-    ``MODEL_RENDERER_MAP`` that routes to ``qwen3.5`` without explicit
-    polarity awareness.
+# Per-model ``enable_thinking`` default, applied when the renderer config
+# leaves it ``None``. The Qwen3.5 family ships two chat-template variants
+# that differ only in the polarity of the gated thinking branch:
+#
+#   * Big sizes (4B / 9B / 35B-A3B / 122B-A10B / 397B-A17B) default
+#     ``enable_thinking=true`` — an open ``<think>\n`` at the gen prompt.
+#   * Small sizes (0.8B / 2B) flip it — default ``false``, emitting the
+#     empty ``<think>\n\n</think>\n\n`` block.
+#
+# These are hard-coded (keyed by ``tokenizer.name_or_path``) rather than
+# probed from the live ``chat_template``: probing meant calling
+# ``apply_chat_template`` at construction, which pulls ``transformers`` onto
+# the hot path and breaks bring-your-own-tokenizer use. The values are the
+# ground truth pinned by ``tests/test_qwen35_size_coverage.py`` — both the
+# polarity assertions and byte-parity against each size's own
+# ``apply_chat_template``.
+_ENABLE_THINKING_DEFAULTS: dict[str, bool] = {
+    "Qwen/Qwen3.5-0.8B": False,
+    "Qwen/Qwen3.5-2B": False,
+    "Qwen/Qwen3.5-4B": True,
+    "Qwen/Qwen3.5-9B": True,
+    "Qwen/Qwen3.5-35B-A3B": True,
+    "Qwen/Qwen3.5-122B-A10B": True,
+    "Qwen/Qwen3.5-397B-A17B": True,
+    # Qwen3.6 extends the Qwen3.5 template; same big-size polarity.
+    "Qwen/Qwen3.6-35B-A3B": True,
+}
+
+
+def _default_enable_thinking(tokenizer) -> bool:
+    """Hard-coded ``enable_thinking`` default for ``tokenizer``'s model.
+
+    Falls back to ``True`` (the big-model default, and the majority of the
+    family) for unknown / fine-tuned checkpoints whose ``name_or_path`` isn't
+    in ``_ENABLE_THINKING_DEFAULTS``; pass an explicit ``enable_thinking=`` to
+    a small-size fine-tune that needs ``False``.
     """
-    try:
-        out = tokenizer.apply_chat_template(
-            [{"role": "user", "content": "x"}],
-            tokenize=False,
-            add_generation_prompt=True,
-        )
-    except Exception:
-        return True
-    if not isinstance(out, str):
-        return True
-    return not out.rstrip().endswith("</think>")
+    return _ENABLE_THINKING_DEFAULTS.get(getattr(tokenizer, "name_or_path", ""), True)
 
 
 class Qwen35Renderer:
@@ -116,13 +121,13 @@ class Qwen35Renderer:
         self._tokenizer = tokenizer
         self._processor = processor
         cfg = config or type(self)._config_cls()
-        # ``enable_thinking=None`` defers to the tokenizer's chat-template
-        # default (Instruct → off, Thinking → on). Materialise here so
-        # downstream reads see a concrete bool; rebind the config with
-        # the resolved value so introspection sees the same.
+        # ``enable_thinking=None`` defers to the model's known default (see
+        # ``_ENABLE_THINKING_DEFAULTS``). Materialise here so downstream reads
+        # see a concrete bool; rebind the config with the resolved value so
+        # introspection sees the same.
         if cfg.enable_thinking is None:
             cfg = cfg.model_copy(
-                update={"enable_thinking": _detect_enable_thinking_default(tokenizer)}
+                update={"enable_thinking": _default_enable_thinking(tokenizer)}
             )
         self.config = cfg
 

{renderers-0.1.8.dev32 → renderers-0.1.8.dev34}/tests/test_qwen35_size_coverage.py

@@ -5,9 +5,8 @@ Seven Qwen3.5 sizes route to ``Qwen35Renderer``. The 4B / 9B / 35B-A3B /
 ``enable_thinking=true``); the smaller 0.8B / 2B sizes ship the polarity-
 flipped variant (default ``enable_thinking=false`` → empty
 ``<think>\\n\\n</think>\\n\\n`` at the gen-prompt boundary). The renderer
-detects polarity from the tokenizer's chat_template at construction, so
-both variants render byte-identical to their own
-``apply_chat_template``.
+hard-codes this polarity per model (``_ENABLE_THINKING_DEFAULTS``), so
+both variants render byte-identical to their own ``apply_chat_template``.
 
 These tests lock in (a) the exact set of Qwen3.5 sizes in the map and
 (b) byte parity for every one of them across representative
@@ -57,7 +56,7 @@ def test_no_other_qwen35_sizes_silently_added():
 
 
 # ---------------------------------------------------------------------------
-# Polarity auto-detection: 0.8B / 2B flip ``enable_thinking`` default.
+# Polarity defaults: 0.8B / 2B flip ``enable_thinking`` default.
 # ---------------------------------------------------------------------------
 
 
@@ -73,10 +72,10 @@ def test_no_other_qwen35_sizes_silently_added():
         ("Qwen/Qwen3.5-397B-A17B", True),
     ],
 )
-def test_qwen35_enable_thinking_polarity_autodetected(qwen35_model, expected_default):
-    """The renderer's ``_enable_thinking`` resolves to the chat template's
-    own default when no explicit flag is passed — so big / small sizes
-    each match their own template at the gen-prompt boundary."""
+def test_qwen35_enable_thinking_polarity_default(qwen35_model, expected_default):
+    """With no explicit flag, the renderer resolves ``enable_thinking`` from
+    the hard-coded per-model default — so big / small sizes each match their
+    own template at the gen-prompt boundary."""
     tok = load_tokenizer(qwen35_model)
     renderer = create_renderer(tok, Qwen35RendererConfig())
     assert isinstance(renderer, Qwen35Renderer)
@@ -86,6 +85,30 @@ def test_qwen35_enable_thinking_polarity_autodetected(qwen35_model, expected_def
     )
 
 
+def test_construction_does_not_call_apply_chat_template():
+    """The ``enable_thinking`` default is hard-coded per model, so building a
+    ``Qwen35Renderer`` must not probe ``apply_chat_template`` — a
+    bring-your-own tokenizer with no chat-template support still works."""
+
+    class _Stub:
+        name_or_path = "Qwen/Qwen3.5-0.8B"
+        unk_token_id = -1
+
+        def convert_tokens_to_ids(self, token):
+            # Any stable non-unk id per token; the renderer only needs the
+            # special tokens to resolve to distinct, in-vocab ids.
+            return abs(hash(token)) % 1_000_000 + 1
+
+        def apply_chat_template(self, *args, **kwargs):
+            raise AssertionError(
+                "apply_chat_template must not be called at construction"
+            )
+
+    renderer = Qwen35Renderer(_Stub())
+    # 0.8B is a small size → thinking defaults off, from the hard-coded table.
+    assert renderer.config.enable_thinking is False
+
+
 # ---------------------------------------------------------------------------
 # Byte parity for each in-map Qwen3.5 size.
 # ---------------------------------------------------------------------------
@@ -146,7 +169,7 @@ def test_qwen35_size_parity_with_apply_chat_template(
     """Each in-map Qwen3.5 size renders byte-identical to its own
     ``apply_chat_template`` output. Locks in the property that lets us
     share ``Qwen35Renderer`` across all seven sizes — the polarity
-    flip on 0.8B / 2B is absorbed by the constructor's auto-detect."""
+    flip on 0.8B / 2B is absorbed by the per-model default."""
     tok = load_tokenizer(qwen35_model)
     renderer = create_renderer(tok, Qwen35RendererConfig())
     assert isinstance(renderer, Qwen35Renderer)