renderers 0.1.10.dev13__tar.gz → 0.1.11.dev1__tar.gz

{renderers-0.1.10.dev13 → renderers-0.1.11.dev1}/.github/workflows/publish-dev.yml

@@ -62,6 +62,6 @@ jobs:
           path: dist/
 
       - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0
+        uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # v1.14.2
         with:
           skip-existing: true

{renderers-0.1.10.dev13 → renderers-0.1.11.dev1}/.github/workflows/publish.yml

@@ -87,4 +87,4 @@ jobs:
           path: dist/
 
       - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0
+        uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # v1.14.2

{renderers-0.1.10.dev13 → renderers-0.1.11.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: renderers
-Version: 0.1.10.dev13
+Version: 0.1.11.dev1
 Summary: Chat template renderers — deterministic message-to-token conversion for LLM training
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -56,7 +56,7 @@ next_prompt_ids = r.bridge_to_next_turn(
 )
 ```
 
-Hand-coded renderers ship for `qwen3`, `qwen3-vl`, `qwen3.5`, `qwen3.6`, `gemma4`, `glm-5`, `glm-5.1`, `glm-4.5`, `minimax-m2`, `deepseek-v3`, `deepseek-r1`, `kimi-k2`, `kimi-k2.5` / `kimi-k2.6`, `laguna-xs.2`, `laguna-xs-2.1`, `laguna-s-2.1`, `laguna-m.1`, `nemotron-3`, `nemotron-3-ultra`, `nemotron-3.5`, `llama-3`, `gpt-oss`, `hy3`, `inkling` / `inkling-small`, and `prime-qwen3`. Anything else falls back to `DefaultRenderer`, a generic `apply_chat_template` wrapper. `qwen3-vl`, `qwen3.5`, `qwen3.6`, `gemma4`, `kimi-k2.5` / `kimi-k2.6`, and the Inkling checkpoints are multimodal (Inkling handles both image **and** audio).
+Hand-coded renderers ship for `qwen3`, `qwen3-vl`, `qwen3.5`, `qwen3.6`, `qwen3.8`, `gemma4`, `glm-5`, `glm-5.1`, `glm-4.5`, `minimax-m2`, `deepseek-v3`, `deepseek-r1`, `kimi-k2`, `kimi-k2.5` / `kimi-k2.6`, `laguna-xs.2`, `laguna-xs-2.1`, `laguna-s-2.1`, `laguna-m.1`, `nemotron-3`, `nemotron-3-ultra`, `nemotron-3.5`, `llama-3`, `gpt-oss`, `hy3`, `inkling` / `inkling-small`, and `prime-qwen3`. Anything else falls back to `DefaultRenderer`, a generic `apply_chat_template` wrapper. `qwen3-vl`, `qwen3.5`, `qwen3.6`, `qwen3.8`, `gemma4`, `kimi-k2.5` / `kimi-k2.6`, and the Inkling checkpoints are multimodal (Inkling handles both image **and** audio).
 
 ## API
 

{renderers-0.1.10.dev13 → renderers-0.1.11.dev1}/README.md

@@ -40,7 +40,7 @@ next_prompt_ids = r.bridge_to_next_turn(
 )
 ```
 
-Hand-coded renderers ship for `qwen3`, `qwen3-vl`, `qwen3.5`, `qwen3.6`, `gemma4`, `glm-5`, `glm-5.1`, `glm-4.5`, `minimax-m2`, `deepseek-v3`, `deepseek-r1`, `kimi-k2`, `kimi-k2.5` / `kimi-k2.6`, `laguna-xs.2`, `laguna-xs-2.1`, `laguna-s-2.1`, `laguna-m.1`, `nemotron-3`, `nemotron-3-ultra`, `nemotron-3.5`, `llama-3`, `gpt-oss`, `hy3`, `inkling` / `inkling-small`, and `prime-qwen3`. Anything else falls back to `DefaultRenderer`, a generic `apply_chat_template` wrapper. `qwen3-vl`, `qwen3.5`, `qwen3.6`, `gemma4`, `kimi-k2.5` / `kimi-k2.6`, and the Inkling checkpoints are multimodal (Inkling handles both image **and** audio).
+Hand-coded renderers ship for `qwen3`, `qwen3-vl`, `qwen3.5`, `qwen3.6`, `qwen3.8`, `gemma4`, `glm-5`, `glm-5.1`, `glm-4.5`, `minimax-m2`, `deepseek-v3`, `deepseek-r1`, `kimi-k2`, `kimi-k2.5` / `kimi-k2.6`, `laguna-xs.2`, `laguna-xs-2.1`, `laguna-s-2.1`, `laguna-m.1`, `nemotron-3`, `nemotron-3-ultra`, `nemotron-3.5`, `llama-3`, `gpt-oss`, `hy3`, `inkling` / `inkling-small`, and `prime-qwen3`. Anything else falls back to `DefaultRenderer`, a generic `apply_chat_template` wrapper. `qwen3-vl`, `qwen3.5`, `qwen3.6`, `qwen3.8`, `gemma4`, `kimi-k2.5` / `kimi-k2.6`, and the Inkling checkpoints are multimodal (Inkling handles both image **and** audio).
 
 ## API
 

{renderers-0.1.10.dev13 → renderers-0.1.11.dev1}/docs/renderer-config.md

@@ -31,6 +31,7 @@ definition time. Template fields are covered by parity tests against
 | PrimeIntellect Qwen3 | `PrimeQwen3RendererConfig` | - | - |
 | Qwen3.5 | `Qwen35RendererConfig` | `enable_thinking`, `add_vision_id` | `image_cache_max` |
 | Qwen3.6 | `Qwen36RendererConfig` | `enable_thinking`, `add_vision_id`, `preserve_thinking` | `image_cache_max` |
+| Qwen3.8 | `Qwen38RendererConfig` | `enable_thinking`, `add_vision_id`, `preserve_thinking`, `reasoning_effort` | `image_cache_max` |
 | Qwen3-VL | `Qwen3VLRendererConfig` | `add_vision_id` | `image_cache_max` |
 | Gemma 4 | `Gemma4RendererConfig` | `enable_thinking`, `preserve_thinking` | `image_cache_max` |
 | GLM-5 / 5.1 | `GLM5RendererConfig` / `GLM51RendererConfig` | `enable_thinking`, `clear_thinking` | - |
@@ -140,6 +141,7 @@ the knobs its template actually exposes:
 | Qwen3 | `enable_thinking=False -> all`, else `tool_cycle` |
 | Qwen3.5 | `enable_thinking=False -> all`, else `tool_cycle` |
 | Qwen3.6 | `preserve_thinking=True -> all`; else `enable_thinking=False -> all`; else `tool_cycle` |
+| Qwen3.8 | `preserve_thinking=True -> all`; else `enable_thinking=False -> all`; else `tool_cycle` |
 | Gemma 4 | `preserve_thinking=True -> all`; else `enable_thinking=False -> all`; else `tool_cycle` |
 | GLM-5 / 5.1 | `clear_thinking=False -> all`; else `enable_thinking=False -> all`; else `tool_cycle` |
 | GLM-4.5 | `enable_thinking=False -> all`, else `tool_cycle` |

{renderers-0.1.10.dev13 → renderers-0.1.11.dev1}/renderers/__init__.py

@@ -68,6 +68,7 @@ from renderers.configs import (
     PrimeQwen3RendererConfig,
     Qwen35RendererConfig,
     Qwen36RendererConfig,
+    Qwen38RendererConfig,
     Qwen3RendererConfig,
     Qwen3VLRendererConfig,
     RendererConfig,
@@ -109,6 +110,7 @@ _LAZY_RENDERERS: dict[str, str] = {
     "PrimeQwen3Renderer": "renderers.prime_qwen3",
     "Qwen35Renderer": "renderers.qwen35",
     "Qwen36Renderer": "renderers.qwen36",
+    "Qwen38Renderer": "renderers.qwen38",
     "Qwen3Renderer": "renderers.qwen3",
     "Qwen3VLRenderer": "renderers.qwen3_vl",
 }
@@ -192,6 +194,8 @@ __all__ = [
     "Qwen35RendererConfig",
     "Qwen36Renderer",
     "Qwen36RendererConfig",
+    "Qwen38Renderer",
+    "Qwen38RendererConfig",
     "Qwen3Renderer",
     "Qwen3RendererConfig",
     "Qwen3VLRenderer",

{renderers-0.1.10.dev13 → renderers-0.1.11.dev1}/renderers/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.10.dev13'
-__version_tuple__ = version_tuple = (0, 1, 10, 'dev13')
+__version__ = version = '0.1.11.dev1'
+__version_tuple__ = version_tuple = (0, 1, 11, 'dev1')
 
 __commit_id__ = commit_id = None

{renderers-0.1.10.dev13 → renderers-0.1.11.dev1}/renderers/base.py

@@ -794,10 +794,10 @@ class MultimodalRenderer(Renderer, Protocol):
     """A :class:`Renderer` that supports multimodal inputs (images, video).
 
     Concrete classes (``Qwen3VLRenderer``, ``Qwen35Renderer``,
-    ``Qwen36Renderer``, ``KimiK25Renderer``) implement this Protocol
-    structurally — no explicit inheritance required. Callers that need
-    to drive vLLM's ``multi_modal_data`` features field or carry images
-    forward across turns should dispatch on ``isinstance(r,
+    ``Qwen36Renderer``, ``Qwen38Renderer``, ``KimiK25Renderer``) implement
+    this Protocol structurally — no explicit inheritance required.
+    Callers that need to drive vLLM's ``multi_modal_data`` features field or
+    carry images forward across turns should dispatch on ``isinstance(r,
     MultimodalRenderer)`` and use the extended ``bridge_to_next_turn``
     signature below.
     """
@@ -1031,6 +1031,9 @@ MODEL_RENDERER_MAP: dict[str, str] = {
     "Qwen/Qwen3.5-397B-A17B": "qwen3.5",
     # Qwen3.6.
     "Qwen/Qwen3.6-35B-A3B": "qwen3.6",
+    # Qwen3.8.
+    "Qwen/Qwen3.8-27B": "qwen3.8",
+    "Qwen/Qwen3.8-Flash-Next": "qwen3.8",
     # Qwen3-VL.
     "Qwen/Qwen3-VL-4B-Instruct": "qwen3-vl",
     "Qwen/Qwen3-VL-8B-Instruct": "qwen3-vl",
@@ -1136,6 +1139,9 @@ MULTIMODAL_MODELS: dict[str, set[str]] = {
     # Qwen3.6 extends Qwen3.5's chat template; same VL bits, only
     # tool-call argument serialization differs.
     "Qwen/Qwen3.6-35B-A3B": {"image"},
+    # Qwen3.8 adds reasoning-effort control and preserves thinking by default.
+    "Qwen/Qwen3.8-27B": {"image"},
+    "Qwen/Qwen3.8-Flash-Next": {"image"},
     # Kimi K2.5 / K2.6 are unified VLMs (HF tag ``image-text-to-text``)
     # with custom processor (``KimiK25Processor`` + ``KimiK25VisionProcessor``).
     # Vision wrap is different from Qwen-VL:
@@ -1367,6 +1373,7 @@ def _populate_registry():
     from renderers.qwen3_vl import Qwen3VLRenderer
     from renderers.qwen35 import Qwen35Renderer
     from renderers.qwen36 import Qwen36Renderer
+    from renderers.qwen38 import Qwen38Renderer
 
     RENDERER_REGISTRY.update(
         {
@@ -1377,6 +1384,7 @@ def _populate_registry():
             "gemma4": Gemma4Renderer,
             "qwen3.5": Qwen35Renderer,
             "qwen3.6": Qwen36Renderer,
+            "qwen3.8": Qwen38Renderer,
             "glm-5": GLM5Renderer,
             "glm-5.1": GLM51Renderer,
             "glm-4.5": GLM45Renderer,

{renderers-0.1.10.dev13 → renderers-0.1.11.dev1}/renderers/configs.py

@@ -271,6 +271,52 @@ class Qwen36RendererConfig(BaseRendererConfig):
         return self
 
 
+class Qwen38RendererConfig(BaseRendererConfig):
+    """Qwen3.8 renderer config.
+
+    Qwen3.8 keeps Qwen3.6's multimodal/tool template and adds native
+    reasoning-effort instructions. Historical thinking is preserved by
+    default in the upstream template.
+    """
+
+    name: Literal["qwen3.8"] = "qwen3.8"
+    _template_fields = frozenset(
+        {
+            "enable_thinking",
+            "add_vision_id",
+            "preserve_thinking",
+            "reasoning_effort",
+        }
+    )
+
+    enable_thinking: bool | None = None
+    """See :class:`Qwen35RendererConfig.enable_thinking`."""
+
+    add_vision_id: bool = False
+    """See :class:`Qwen35RendererConfig.add_vision_id`."""
+
+    preserve_thinking: bool = True
+    """Keep historical ``<think>`` blocks. Mirrors Qwen3.8's default."""
+
+    reasoning_effort: Literal["xhigh", "medium", "low"] = "xhigh"
+    """Reasoning depth hint injected into the system prompt when enabled."""
+
+    image_cache_max: int = 256
+    """See :class:`Qwen35RendererConfig.image_cache_max`."""
+
+    _internal_fields = frozenset({"image_cache_max"})
+
+    @model_validator(mode="after")
+    def _check_thinking_retention(self):
+        _reject_thinking_retention_conflict(
+            self,
+            "preserve_thinking",
+            true_implies="all",
+            false_implies="tool_cycle",
+        )
+        return self
+
+
 class Qwen3VLRendererConfig(BaseRendererConfig):
     """Qwen3-VL renderer config."""
 
@@ -892,6 +938,7 @@ RendererConfig = Annotated[
         PrimeQwen3RendererConfig,
         Qwen35RendererConfig,
         Qwen36RendererConfig,
+        Qwen38RendererConfig,
         Qwen3VLRendererConfig,
         Gemma4RendererConfig,
         GLM5RendererConfig,
@@ -937,6 +984,7 @@ _CONFIG_BY_NAME: dict[str, type[BaseRendererConfig]] = {
     "prime-qwen3": PrimeQwen3RendererConfig,
     "qwen3.5": Qwen35RendererConfig,
     "qwen3.6": Qwen36RendererConfig,
+    "qwen3.8": Qwen38RendererConfig,
     "qwen3-vl": Qwen3VLRendererConfig,
     "gemma4": Gemma4RendererConfig,
     "glm-5": GLM5RendererConfig,
@@ -1013,6 +1061,7 @@ __all__ = [
     "PrimeQwen3RendererConfig",
     "Qwen35RendererConfig",
     "Qwen36RendererConfig",
+    "Qwen38RendererConfig",
     "Qwen3RendererConfig",
     "Qwen3VLRendererConfig",
     "RendererConfig",

{renderers-0.1.10.dev13 → renderers-0.1.11.dev1}/renderers/qwen35.py

@@ -102,6 +102,9 @@ _ENABLE_THINKING_DEFAULTS: dict[str, bool] = {
     "Qwen/Qwen3.5-397B-A17B": True,
     # Qwen3.6 extends the Qwen3.5 template; same big-size polarity.
     "Qwen/Qwen3.6-35B-A3B": True,
+    # Qwen3.8 keeps thinking enabled by default.
+    "Qwen/Qwen3.8-27B": True,
+    "Qwen/Qwen3.8-Flash-Next": True,
 }
 
 
@@ -305,6 +308,41 @@ class Qwen35Renderer:
                 return i
         return len(messages)
 
+    def _reasoning_instructions(self) -> str:
+        """Optional synthetic system instruction for reasoning control.
+
+        Qwen3.5 and Qwen3.6 do not inject one. Newer family members can
+        override this hook without duplicating the full render path.
+        """
+        return ""
+
+    def _omit_empty_system_message(self) -> bool:
+        """Whether an empty caller-provided system message emits no tokens."""
+        return False
+
+    @staticmethod
+    def _extract_assistant_parts(msg: Message, content: str) -> tuple[str, str]:
+        """Return ``(reasoning_content, visible_content)`` for an assistant.
+
+        Qwen3.5 and Qwen3.6 accept the legacy inline
+        ``<think>...</think>content`` shape when ``reasoning_content`` is
+        absent. Qwen3.8 removes that compatibility branch and overrides this
+        hook to keep inline markers in visible content.
+        """
+        reasoning_content = ""
+        if isinstance(msg.get("reasoning_content"), str):
+            reasoning_content = msg["reasoning_content"]
+        elif "</think>" in content:
+            before_think_end, after_think_end = content.split("</think>", 1)
+            if "<think>" in before_think_end:
+                reasoning_content = before_think_end.split("<think>")[-1].lstrip("\n")
+            else:
+                reasoning_content = before_think_end.lstrip("\n")
+            reasoning_content = reasoning_content.rstrip("\n")
+            content = after_think_end.lstrip("\n")
+
+        return reasoning_content.strip(), content
+
     # ------------------------------------------------------------------
     # Core render method
     # ------------------------------------------------------------------
@@ -466,6 +504,7 @@ class Qwen35Renderer:
 
         # ── 1. System message + optional tools ──────────────────────
         first_is_system = messages[0].get("role") == "system"
+        reasoning_instructions = self._reasoning_instructions()
 
         if tools:
             # System message index for attribution
@@ -477,10 +516,10 @@ class Qwen35Renderer:
             # JSON tool specs — is scaffold. The tools dict is
             # recoverable from the ``tools`` argument; don't re-attribute
             # its embedded JSON as message body.
-            segments: list[tuple[str, bool]] = [
-                ("system\n", False),
-                (_TOOLS_HEADER, False),
-            ]
+            segments: list[tuple[str, bool]] = [("system\n", False)]
+            if reasoning_instructions:
+                segments.append((reasoning_instructions + "\n\n", False))
+            segments.append((_TOOLS_HEADER, False))
             for tool in tools:
                 segments.append(("\n" + json.dumps(tool, ensure_ascii=False), False))
             segments.append((_TOOLS_FOOTER, False))
@@ -495,13 +534,33 @@ class Qwen35Renderer:
             emit_text("\n", sys_idx, is_sampled=False, is_content=False)
         elif first_is_system:
             sys_content = self._render_content(messages[0].get("content")).strip()
-            emit_special(self._im_start, 0, is_sampled=False, is_content=False)
-            sys_segments: list[tuple[str, bool]] = [("system\n", False)]
-            if sys_content:
-                sys_segments.append((sys_content, True))
-            emit_text_segments(sys_segments, 0, is_sampled=False)
-            emit_special(self._im_end, 0, is_sampled=False, is_content=False)
-            emit_text("\n", 0, is_sampled=False, is_content=False)
+            if (
+                sys_content
+                or reasoning_instructions
+                or not self._omit_empty_system_message()
+            ):
+                emit_special(self._im_start, 0, is_sampled=False, is_content=False)
+                sys_segments: list[tuple[str, bool]] = [("system\n", False)]
+                if reasoning_instructions:
+                    separator = "\n\n" if sys_content else ""
+                    sys_segments.append((reasoning_instructions + separator, False))
+                if sys_content:
+                    sys_segments.append((sys_content, True))
+                emit_text_segments(sys_segments, 0, is_sampled=False)
+                emit_special(self._im_end, 0, is_sampled=False, is_content=False)
+                emit_text("\n", 0, is_sampled=False, is_content=False)
+        elif reasoning_instructions:
+            # Qwen3.8 injects reasoning guidance even when the caller did
+            # not provide a system message. It is renderer scaffold, so use
+            # the synthetic ``-1`` attribution bucket.
+            emit_special(self._im_start, -1, is_sampled=False, is_content=False)
+            emit_text_segments(
+                [("system\n", False), (reasoning_instructions, False)],
+                -1,
+                is_sampled=False,
+            )
+            emit_special(self._im_end, -1, is_sampled=False, is_content=False)
+            emit_text("\n", -1, is_sampled=False, is_content=False)
 
         # ── 2. Compute last_query_index ─────────────────────────────
         last_qi = self._last_query_index(messages)
@@ -932,22 +991,7 @@ class Qwen35Renderer:
         emit_ids,
         emit_text_segments,
     ) -> None:
-        # Extract reasoning_content
-        reasoning_content = ""
-        if isinstance(msg.get("reasoning_content"), str):
-            reasoning_content = msg["reasoning_content"]
-        elif "</think>" in content:
-            # Split on </think> to separate reasoning from content
-            before_think_end, after_think_end = content.split("</think>", 1)
-            # Extract text after <think> (if present)
-            if "<think>" in before_think_end:
-                reasoning_content = before_think_end.split("<think>")[-1].lstrip("\n")
-            else:
-                reasoning_content = before_think_end.lstrip("\n")
-            reasoning_content = reasoning_content.rstrip("\n")
-            content = after_think_end.lstrip("\n")
-
-        reasoning_content = reasoning_content.strip()
+        reasoning_content, content = self._extract_assistant_parts(msg, content)
 
         # ``<|im_start|>assistant\n`` is template-injected scaffolding —
         # at inference the chat template emits these as the generation

renderers-0.1.11.dev1/renderers/qwen38.py

@@ -0,0 +1,66 @@
+"""Qwen3.8 Renderer — mirrors the Qwen3.8 Jinja chat template.
+
+Qwen3.8 retains Qwen3.6's multimodal message grammar and JSON-safe tool
+argument serialization, with three template changes:
+
+- ``reasoning_effort`` can be ``xhigh`` (default), ``medium``, or ``low``;
+  xhigh/low inject a matching instruction into the system prompt.
+- ``preserve_thinking`` defaults to true, so historical reasoning blocks are
+  retained unless explicitly disabled.
+- Legacy inline ``<think>...</think>`` text is no longer split out of
+  assistant ``content``; only ``reasoning_content`` populates the reasoning
+  block.
+"""
+
+from __future__ import annotations
+
+from renderers.base import Message
+from renderers.configs import Qwen38RendererConfig
+from renderers.qwen35 import Qwen35Renderer
+from renderers.qwen36 import Qwen36Renderer
+
+
+_REASONING_INSTRUCTIONS = {
+    "xhigh": (
+        "Reasoning effort is set to xhigh. Please think carefully through the "
+        "task, validate key assumptions, consider plausible alternatives, and "
+        "prioritize correctness, consistency, and clarity in the final answer."
+    ),
+    "medium": "",
+    "low": (
+        "Reasoning effort is set to low. Keep your thinking brief and focused, "
+        "moving directly to the conclusion without unnecessary elaboration."
+    ),
+}
+
+
+class Qwen38Renderer(Qwen36Renderer):
+    """Deterministic message-to-token renderer for Qwen3.8 models."""
+
+    config: Qwen38RendererConfig
+    _config_cls = Qwen38RendererConfig
+
+    def _reasoning_instructions(self) -> str:
+        if not self.config.enable_thinking:
+            return ""
+        return _REASONING_INSTRUCTIONS[self.config.reasoning_effort]
+
+    def _omit_empty_system_message(self) -> bool:
+        return True
+
+    @staticmethod
+    def _last_query_index(messages: list[Message]) -> int:
+        last_query_index = Qwen35Renderer._last_query_index(messages)
+        if last_query_index == len(messages):
+            raise ValueError("No user query found in messages.")
+        return last_query_index
+
+    @staticmethod
+    def _extract_assistant_parts(msg: Message, content: str) -> tuple[str, str]:
+        reasoning_content = msg.get("reasoning_content")
+        if not isinstance(reasoning_content, str):
+            reasoning_content = ""
+        return reasoning_content.strip(), content
+
+
+__all__ = ["Qwen38Renderer"]

{renderers-0.1.10.dev13 → renderers-0.1.11.dev1}/tests/conftest.py

@@ -22,6 +22,8 @@ RENDERER_MODELS = [
     ("PrimeIntellect/Qwen3-0.6B", "auto"),
     ("Qwen/Qwen3.5-9B", "auto"),
     ("Qwen/Qwen3.6-35B-A3B", "auto"),
+    ("Qwen/Qwen3.8-27B", "auto"),
+    ("Qwen/Qwen3.8-Flash-Next", "auto"),
     ("Qwen/Qwen3-VL-4B-Instruct", "auto"),
     ("google/gemma-4-31B-it", "auto"),
     ("zai-org/GLM-5", "auto"),

{renderers-0.1.10.dev13 → renderers-0.1.11.dev1}/tests/test_bridge.py

@@ -26,6 +26,8 @@ _BRIDGE_MODELS = [
     ("PrimeIntellect/Qwen3-0.6B", "auto"),
     ("Qwen/Qwen3.5-9B", "auto"),
     ("Qwen/Qwen3.6-35B-A3B", "auto"),
+    ("Qwen/Qwen3.8-27B", "auto"),
+    ("Qwen/Qwen3.8-Flash-Next", "auto"),
     ("google/gemma-4-31B-it", "auto"),
     ("thinkingmachines/Inkling", "auto"),
     ("thinkingmachines/Inkling-Small", "auto"),

{renderers-0.1.10.dev13 → renderers-0.1.11.dev1}/tests/test_client.py

@@ -384,8 +384,10 @@ def test_generate_threads_prompt_attribution_through_prebuilt_prompt_path():
     [
         ("Qwen/Qwen3-VL-4B-Instruct", "renderers.qwen3_vl:Qwen3VLRenderer"),
         ("Qwen/Qwen3.5-2B", "renderers.qwen35:Qwen35Renderer"),
+        ("Qwen/Qwen3.8-27B", "renderers.qwen38:Qwen38Renderer"),
+        ("Qwen/Qwen3.8-Flash-Next", "renderers.qwen38:Qwen38Renderer"),
     ],
-    ids=["qwen3_vl", "qwen35"],
+    ids=["qwen3_vl", "qwen35", "qwen38", "qwen38_flash_next"],
 )
 def test_generate_serializes_multimodal_features_for_qwen_vl_family(
     model_id, renderer_class_path

{renderers-0.1.10.dev13 → renderers-0.1.11.dev1}/tests/test_disabled_thinking_stability.py

@@ -32,6 +32,7 @@ from renderers.configs import (
     Qwen3RendererConfig,
     Qwen35RendererConfig,
     Qwen36RendererConfig,
+    Qwen38RendererConfig,
 )
 
 # One representative model per affected renderer family, each with
@@ -40,6 +41,14 @@ _MODELS = [
     ("Qwen/Qwen3-8B", Qwen3RendererConfig(enable_thinking=False)),
     ("Qwen/Qwen3.5-9B", Qwen35RendererConfig(enable_thinking=False)),
     ("Qwen/Qwen3.6-35B-A3B", Qwen36RendererConfig(enable_thinking=False)),
+    (
+        "Qwen/Qwen3.8-27B",
+        Qwen38RendererConfig(enable_thinking=False),
+    ),
+    (
+        "Qwen/Qwen3.8-Flash-Next",
+        Qwen38RendererConfig(enable_thinking=False),
+    ),
     (
         "google/gemma-4-26B-A4B-it",
         Gemma4RendererConfig(enable_thinking=False),

renderers-0.1.11.dev1/tests/test_qwen38.py

@@ -0,0 +1,178 @@
+"""Focused Qwen3.8 registration and upstream-template parity coverage."""
+
+from __future__ import annotations
+
+from functools import lru_cache
+
+import pytest
+from pydantic import TypeAdapter
+
+from renderers import (
+    Qwen38Renderer,
+    Qwen38RendererConfig,
+    RendererConfig,
+    create_renderer,
+)
+from renderers.base import MODEL_RENDERER_MAP, MULTIMODAL_MODELS, load_tokenizer
+
+
+TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "get_weather",
+            "description": "Get weather for a city",
+            "parameters": {
+                "type": "object",
+                "properties": {"city": {"type": "string"}},
+                "required": ["city"],
+            },
+        },
+    }
+]
+
+QWEN38_MODELS = ["Qwen/Qwen3.8-27B", "Qwen/Qwen3.8-Flash-Next"]
+
+
+@lru_cache(maxsize=None)
+def _qwen38(model_name):
+    tokenizer = load_tokenizer(model_name)
+    return tokenizer, create_renderer(tokenizer)
+
+
+def _expected(tokenizer, messages, **kwargs):
+    result = tokenizer.apply_chat_template(
+        messages,
+        tokenize=True,
+        return_dict=False,
+        **kwargs,
+    )
+    return list(result)
+
+
+@pytest.mark.parametrize("qwen38_model", QWEN38_MODELS)
+def test_qwen38_is_registered_with_native_defaults(qwen38_model):
+    tokenizer, renderer = _qwen38(qwen38_model)
+
+    assert tokenizer.name_or_path == qwen38_model
+    assert MODEL_RENDERER_MAP[tokenizer.name_or_path] == "qwen3.8"
+    assert MULTIMODAL_MODELS[tokenizer.name_or_path] == {"image"}
+    assert isinstance(renderer, Qwen38Renderer)
+    assert renderer.config.enable_thinking is True
+    assert renderer.config.reasoning_effort == "xhigh"
+    assert renderer.config.preserve_thinking is True
+    assert renderer.effective_thinking_retention == "all"
+
+
+def test_qwen38_config_discriminator():
+    parsed = TypeAdapter(RendererConfig).validate_python(
+        {
+            "name": "qwen3.8",
+            "reasoning_effort": "low",
+            "preserve_thinking": False,
+        }
+    )
+
+    assert isinstance(parsed, Qwen38RendererConfig)
+    assert parsed.reasoning_effort == "low"
+    assert parsed.preserve_thinking is False
+
+
+@pytest.mark.parametrize(
+    "config_kwargs",
+    [
+        pytest.param({}, id="defaults"),
+        pytest.param({"reasoning_effort": "xhigh"}, id="xhigh"),
+        pytest.param({"reasoning_effort": "medium"}, id="medium"),
+        pytest.param({"reasoning_effort": "low"}, id="low"),
+        pytest.param({"enable_thinking": False}, id="thinking-disabled"),
+        pytest.param({"preserve_thinking": False}, id="drop-history-thinking"),
+    ],
+)
+@pytest.mark.parametrize("qwen38_model", QWEN38_MODELS)
+def test_qwen38_text_and_tool_parity(config_kwargs, qwen38_model):
+    tokenizer, _ = _qwen38(qwen38_model)
+    renderer = Qwen38Renderer(tokenizer, Qwen38RendererConfig(**config_kwargs))
+    cases = [
+        (
+            [
+                {"role": "system", "content": "Be concise."},
+                {"role": "user", "content": "Hello."},
+            ],
+            {"add_generation_prompt": True},
+        ),
+        (
+            [
+                {"role": "system", "content": ""},
+                {"role": "user", "content": "Hello."},
+            ],
+            {"add_generation_prompt": True},
+        ),
+        (
+            [
+                {"role": "user", "content": "First question."},
+                {
+                    "role": "assistant",
+                    "reasoning_content": "First thought.",
+                    "content": "First answer.",
+                },
+                {"role": "user", "content": "Second question."},
+                {
+                    "role": "assistant",
+                    "reasoning_content": "Second thought.",
+                    "content": "Second answer.",
+                },
+            ],
+            {},
+        ),
+        (
+            [
+                {"role": "user", "content": "Weather in Paris?"},
+                {
+                    "role": "assistant",
+                    "content": "",
+                    "tool_calls": [
+                        {
+                            "function": {
+                                "name": "get_weather",
+                                "arguments": {"city": "Paris", "fresh": True},
+                            }
+                        }
+                    ],
+                },
+                {"role": "tool", "content": '{"temperature": 20}'},
+            ],
+            {"tools": TOOLS, "add_generation_prompt": True},
+        ),
+    ]
+
+    for messages, render_kwargs in cases:
+        expected = _expected(
+            tokenizer,
+            messages,
+            **config_kwargs,
+            **render_kwargs,
+        )
+        assert renderer.render_ids(messages, **render_kwargs) == expected
+
+
+@pytest.mark.parametrize("qwen38_model", QWEN38_MODELS)
+def test_qwen38_keeps_inline_think_markup_in_visible_content(qwen38_model):
+    tokenizer, renderer = _qwen38(qwen38_model)
+    messages = [
+        {"role": "user", "content": "Echo this."},
+        {
+            "role": "assistant",
+            "content": "<think>literal markup</think>visible content",
+        },
+    ]
+
+    assert renderer.render_ids(messages) == _expected(tokenizer, messages)
+
+
+@pytest.mark.parametrize("qwen38_model", QWEN38_MODELS)
+def test_qwen38_requires_a_real_user_query(qwen38_model):
+    _, renderer = _qwen38(qwen38_model)
+
+    with pytest.raises(ValueError, match="No user query found"):
+        renderer.render_ids([{"role": "system", "content": "System only."}])

{renderers-0.1.10.dev13 → renderers-0.1.11.dev1}/tests/test_renderer_config_parity.py

@@ -47,6 +47,8 @@ _RENDERER_MODELS = [
     ("Qwen/Qwen3-8B", "auto"),
     ("Qwen/Qwen3.5-9B", "auto"),
     ("Qwen/Qwen3.6-35B-A3B", "auto"),
+    ("Qwen/Qwen3.8-27B", "auto"),
+    ("Qwen/Qwen3.8-Flash-Next", "auto"),
     ("google/gemma-4-31B-it", "auto"),
     ("zai-org/GLM-5", "auto"),
     ("zai-org/GLM-5.1", "auto"),
@@ -93,7 +95,7 @@ _KWARG_VALUES: dict[str, list[Any]] = {
     # gpt-oss accepts low/medium/high; Hy3 accepts no_think/low/high. The
     # union is listed here and the matrix builder drops values a given
     # renderer's typed config rejects (see ``_value_valid_for``).
-    "reasoning_effort": ["no_think", "low", "medium", "high"],
+    "reasoning_effort": ["no_think", "low", "medium", "high", "xhigh"],
     # Hy3 — keep <think>{reasoning}</think> on historical assistant turns
     # (True) vs collapse past-cycle reasoning to <think></think> (False).
     "preserved_thinking": [True, False],
@@ -131,10 +133,11 @@ _KWARG_VALUES: dict[str, list[Any]] = {
     # passthrough mode. The renderer paths diverge significantly under
     # this flag, so both values are exercised.
     "render_assistant_messages_raw": [True, False],
-    # Qwen3.5 / Qwen3.6 / Qwen3-VL — when True, prefix each image /
-    # video placeholder with ``Picture N: `` / ``Video N: ``.
+    # Qwen3.5 / Qwen3.6 / Qwen3.8 / Qwen3-VL — when True, prefix each
+    # image / video placeholder with ``Picture N: `` / ``Video N: ``.
     "add_vision_id": [True, False],
-    # Qwen3.6 — keep historical think blocks before the last real user query.
+    # Qwen3.6 / Qwen3.8 — keep historical think blocks before the last real
+    # user query. Qwen3.8 defaults this to True.
     "preserve_thinking": [True, False],
     # gpt-oss — pin to a fixed date so the renderer's preamble matches
     # the harmony oracle built with the same date. The default

{renderers-0.1.10.dev13 → renderers-0.1.11.dev1}/tests/test_roundtrip.py

@@ -32,6 +32,8 @@ _ROUNDTRIP_MODELS = [
     ("PrimeIntellect/Qwen3-0.6B", "auto"),
     ("Qwen/Qwen3.5-9B", "auto"),
     ("Qwen/Qwen3.6-35B-A3B", "auto"),
+    ("Qwen/Qwen3.8-27B", "auto"),
+    ("Qwen/Qwen3.8-Flash-Next", "auto"),
     ("Qwen/Qwen3-VL-4B-Instruct", "auto"),
     ("google/gemma-4-31B-it", "auto"),
     ("thinkingmachines/Inkling", "auto"),