feat(renderers): add Qwen3.8-27B (dense) renderer

renderers/__init__.py

@@ -68,6 +68,7 @@
     PrimeQwen3RendererConfig,
     Qwen35RendererConfig,
     Qwen36RendererConfig,
+    Qwen38RendererConfig,
     Qwen3RendererConfig,
     Qwen3VLRendererConfig,
     RendererConfig,
@@ -109,6 +110,7 @@
     "PrimeQwen3Renderer": "renderers.prime_qwen3",
     "Qwen35Renderer": "renderers.qwen35",
     "Qwen36Renderer": "renderers.qwen36",
+    "Qwen38Renderer": "renderers.qwen38",
     "Qwen3Renderer": "renderers.qwen3",
     "Qwen3VLRenderer": "renderers.qwen3_vl",
 }
@@ -192,6 +194,8 @@ def __dir__() -> list[str]:
     "Qwen35RendererConfig",
     "Qwen36Renderer",
     "Qwen36RendererConfig",
+    "Qwen38Renderer",
+    "Qwen38RendererConfig",
     "Qwen3Renderer",
     "Qwen3RendererConfig",
     "Qwen3VLRenderer",

renderers/base.py

@@ -1031,6 +1031,11 @@ def bridge_to_next_turn(self, *args: Any, **kwargs: Any) -> "RenderedTokens | No
     "Qwen/Qwen3.5-397B-A17B": "qwen3.5",
     # Qwen3.6.
     "Qwen/Qwen3.6-35B-A3B": "qwen3.6",
+    # Qwen3.8. Dense 27B, built on the Qwen3.5 architecture. Its template
+    # additionally injects reasoning-effort instructions into the system
+    # message and preserves thinking by default (hard-coded per model in
+    # ``Qwen38Renderer`` / ``_ENABLE_THINKING_DEFAULTS``).
+    "Qwen/Qwen3.8-27B": "qwen3.8",
     # Qwen3-VL.
     "Qwen/Qwen3-VL-4B-Instruct": "qwen3-vl",
     "Qwen/Qwen3-VL-8B-Instruct": "qwen3-vl",
@@ -1136,6 +1141,9 @@ def bridge_to_next_turn(self, *args: Any, **kwargs: Any) -> "RenderedTokens | No
     # 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 (dense 27B) is a Qwen3.5-architecture VLM with the same vision
+    # tokens / processor; its renderer shares Qwen35Renderer's image path.
+    "Qwen/Qwen3.8-27B": {"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 +1375,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 +1386,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/configs.py

@@ -271,6 +271,50 @@ def _check_thinking_retention(self):
         return self
 
 
+class Qwen38RendererConfig(BaseRendererConfig):
+    """Qwen3.8 renderer config. Extends Qwen3.5's template surface with
+    reasoning-effort instructions and thinking-preservation defaults."""
+
+    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 `` thinking`` blocks on every assistant turn.
+    Mirrors the Qwen3.8 chat template's ``preserve_thinking`` kwarg, which is
+    *undefined* in the template and therefore defaults to ``True``. Set to
+    ``False`` to restrict thinking blocks to turns after the last real user
+    query (Qwen3.5 behavior)."""
+
+    reasoning_effort: Literal["xhigh", "medium", "low"] | None = None
+    """Reasoning-effort hint injected into the leading system message when
+    thinking is enabled. ``None`` mirrors the template default (``xhigh``);
+    ``medium`` suppresses the instruction string entirely. Mirrors the
+    Qwen3.8 chat template's ``reasoning_effort`` kwarg."""
+
+    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."""
 
@@ -937,6 +981,7 @@ class DeepSeekR1RendererConfig(BaseRendererConfig):
     "prime-qwen3": PrimeQwen3RendererConfig,
     "qwen3.5": Qwen35RendererConfig,
     "qwen3.6": Qwen36RendererConfig,
+    "qwen3.8": Qwen38RendererConfig,
     "qwen3-vl": Qwen3VLRendererConfig,
     "gemma4": Gemma4RendererConfig,
     "glm-5": GLM5RendererConfig,
@@ -1013,6 +1058,7 @@ def config_from_name(name: str) -> BaseRendererConfig | None:
     "PrimeQwen3RendererConfig",
     "Qwen35RendererConfig",
     "Qwen36RendererConfig",
+    "Qwen38RendererConfig",
     "Qwen3RendererConfig",
     "Qwen3VLRendererConfig",
     "RendererConfig",

renderers/qwen35.py

@@ -102,6 +102,8 @@
     "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 (dense 27B) — thinking on by default.
+    "Qwen/Qwen3.8-27B": True,
 }
 
 
@@ -305,6 +307,64 @@ def _last_query_index(messages: list[Message]) -> int:
                 return i
         return len(messages)
 
+    # ------------------------------------------------------------------
+    # System message + optional tools
+    # ------------------------------------------------------------------
+
+    def _emit_system_and_tools(
+        self,
+        messages: list[Message],
+        tools: list[ToolSpec] | None,
+        *,
+        emit_special,
+        emit_text,
+        emit_text_segments,
+    ) -> None:
+        """Emit the leading system message and (optionally) the tools block.
+
+        Qwen3.5 emits a system message only when the caller supplied one.
+        Subclasses (Qwen3.8) override this to inject reasoning-effort
+        instructions and to emit a standalone system message when the
+        template's reasoning instructions are non-empty.
+        """
+        first_is_system = messages[0].get("role") == "system"
+
+        if tools:
+            # System message index for attribution
+            sys_idx = 0 if first_is_system else -1
+
+            emit_special(self._im_start, sys_idx, is_sampled=False, is_content=False)
+            # Body = system content (if any). Everything else in this
+            # block — role tag, tools header / footer / instructions, the
+            # 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),
+            ]
+            for tool in tools:
+                segments.append(("\n" + json.dumps(tool, ensure_ascii=False), False))
+            segments.append((_TOOLS_FOOTER, False))
+            segments.append((_TOOLS_INSTRUCTIONS, False))
+            if first_is_system:
+                sys_content = self._render_content(messages[0].get("content")).strip()
+                if sys_content:
+                    segments.append(("\n\n", False))
+                    segments.append((sys_content, True))
+            emit_text_segments(segments, sys_idx, is_sampled=False)
+            emit_special(self._im_end, sys_idx, is_sampled=False, is_content=False)
+            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)
+
     # ------------------------------------------------------------------
     # Core render method
     # ------------------------------------------------------------------
@@ -465,43 +525,13 @@ def flush_buf() -> None:
             emit_text("\n", msg_idx, is_sampled=False, is_content=False)
 
         # ── 1. System message + optional tools ──────────────────────
-        first_is_system = messages[0].get("role") == "system"
-
-        if tools:
-            # System message index for attribution
-            sys_idx = 0 if first_is_system else -1
-
-            emit_special(self._im_start, sys_idx, is_sampled=False, is_content=False)
-            # Body = system content (if any). Everything else in this
-            # block — role tag, tools header / footer / instructions, the
-            # 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),
-            ]
-            for tool in tools:
-                segments.append(("\n" + json.dumps(tool, ensure_ascii=False), False))
-            segments.append((_TOOLS_FOOTER, False))
-            segments.append((_TOOLS_INSTRUCTIONS, False))
-            if first_is_system:
-                sys_content = self._render_content(messages[0].get("content")).strip()
-                if sys_content:
-                    segments.append(("\n\n", False))
-                    segments.append((sys_content, True))
-            emit_text_segments(segments, sys_idx, is_sampled=False)
-            emit_special(self._im_end, sys_idx, is_sampled=False, is_content=False)
-            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)
+        self._emit_system_and_tools(
+            messages,
+            tools,
+            emit_special=emit_special,
+            emit_text=emit_text,
+            emit_text_segments=emit_text_segments,
+        )
 
         # ── 2. Compute last_query_index ─────────────────────────────
         last_qi = self._last_query_index(messages)
@@ -920,6 +950,30 @@ def _render_arg_value(arg_value: Any) -> str:
             return json.dumps(arg_value, ensure_ascii=False)
         return str(arg_value)
 
+    def _extract_reasoning(self, msg: Message, content: str) -> tuple[str, str]:
+        """Return ``(reasoning_content, content)`` for an assistant message.
+
+        Qwen3.5 falls back to splitting `` response`` out of ``content`` when
+        the message has no explicit ``reasoning_content`` field. Qwen3.8
+        dropped that fallback (it relies solely on ``reasoning_content``), so
+        subclasses override this to skip the content split.
+        """
+        reasoning_content = ""
+        if isinstance(msg.get("reasoning_content"), str):
+            reasoning_content = msg["reasoning_content"]
+        elif " response" in content:
+            # Split on  response to separate reasoning from content
+            before_think_end, after_think_end = content.split(" response", 1)
+            # Extract text after  thinking (if present)
+            if " thinking" in before_think_end:
+                reasoning_content = before_think_end.split(" thinking")[-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
+
     def _render_assistant(
         self,
         msg: Message,
@@ -933,21 +987,7 @@ def _render_assistant(
         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_reasoning(msg, content)
 
         # ``<|im_start|>assistant\n`` is template-injected scaffolding —
         # at inference the chat template emits these as the generation