renderers 0.1.8.dev42__tar.gz → 0.1.8.dev44__tar.gz

{renderers-0.1.8.dev42 → renderers-0.1.8.dev44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: renderers
-Version: 0.1.8.dev42
+Version: 0.1.8.dev44
 Summary: Chat template renderers — deterministic message-to-token conversion for LLM training
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -57,7 +57,7 @@ next_prompt_ids = r.bridge_to_next_turn(
 )
 ```
 
-Hand-coded renderers ship for `qwen3`, `qwen3-vl`, `qwen3.5`, `qwen3.6`, `glm-5`, `glm-5.1`, `glm-4.5`, `minimax-m2`, `deepseek-v3`, `kimi-k2`, `kimi-k2.5`, `nemotron-3`, `gpt-oss`. Anything else falls back to `DefaultRenderer`, a generic `apply_chat_template` wrapper.
+Hand-coded renderers ship for `qwen3`, `qwen3-vl`, `qwen3.5`, `qwen3.6`, `glm-5`, `glm-5.1`, `glm-4.5`, `minimax-m2`, `deepseek-v3`, `kimi-k2`, `kimi-k2.5`, `nemotron-3`, `nemotron-3-ultra`, `gpt-oss`. Anything else falls back to `DefaultRenderer`, a generic `apply_chat_template` wrapper.
 
 ## API
 

{renderers-0.1.8.dev42 → renderers-0.1.8.dev44}/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`, `glm-5`, `glm-5.1`, `glm-4.5`, `minimax-m2`, `deepseek-v3`, `kimi-k2`, `kimi-k2.5`, `nemotron-3`, `gpt-oss`. Anything else falls back to `DefaultRenderer`, a generic `apply_chat_template` wrapper.
+Hand-coded renderers ship for `qwen3`, `qwen3-vl`, `qwen3.5`, `qwen3.6`, `glm-5`, `glm-5.1`, `glm-4.5`, `minimax-m2`, `deepseek-v3`, `kimi-k2`, `kimi-k2.5`, `nemotron-3`, `nemotron-3-ultra`, `gpt-oss`. Anything else falls back to `DefaultRenderer`, a generic `apply_chat_template` wrapper.
 
 ## API
 

{renderers-0.1.8.dev42 → renderers-0.1.8.dev44}/renderers/__init__.py

@@ -44,6 +44,7 @@ from renderers.configs import (
     BaseRendererConfig,
     config_from_name,
     DefaultRendererConfig,
+    DeepSeekR1RendererConfig,
     DeepSeekV3RendererConfig,
     GLM45RendererConfig,
     GLM51RendererConfig,
@@ -55,6 +56,7 @@ from renderers.configs import (
     Llama3RendererConfig,
     MiniMaxM2RendererConfig,
     Nemotron3RendererConfig,
+    Nemotron3UltraRendererConfig,
     Qwen35RendererConfig,
     Qwen36RendererConfig,
     Qwen3RendererConfig,
@@ -74,6 +76,7 @@ from renderers.configs import (
 # imports — ``renderers.base._populate_registry`` lazy-imports the
 # concrete classes itself when a renderer is instantiated.
 _LAZY_RENDERERS: dict[str, str] = {
+    "DeepSeekR1Renderer": "renderers.deepseek_r1",
     "DeepSeekV3Renderer": "renderers.deepseek_v3",
     "DefaultRenderer": "renderers.default",
     "GLM45Renderer": "renderers.glm45",
@@ -86,6 +89,7 @@ _LAZY_RENDERERS: dict[str, str] = {
     "Llama3Renderer": "renderers.llama_3",
     "MiniMaxM2Renderer": "renderers.minimax_m2",
     "Nemotron3Renderer": "renderers.nemotron3",
+    "Nemotron3UltraRenderer": "renderers.nemotron3",
     "Qwen35Renderer": "renderers.qwen35",
     "Qwen36Renderer": "renderers.qwen36",
     "Qwen3Renderer": "renderers.qwen3",
@@ -113,6 +117,8 @@ __all__ = [
     "BaseRendererConfig",
     "Content",
     "ContentPart",
+    "DeepSeekR1Renderer",
+    "DeepSeekR1RendererConfig",
     "DeepSeekV3Renderer",
     "DeepSeekV3RendererConfig",
     "DefaultRenderer",
@@ -142,6 +148,8 @@ __all__ = [
     "MultimodalRenderer",
     "Nemotron3Renderer",
     "Nemotron3RendererConfig",
+    "Nemotron3UltraRenderer",
+    "Nemotron3UltraRendererConfig",
     "OverlongPromptError",
     "ParsedResponse",
     "ParsedToolCall",

{renderers-0.1.8.dev42 → renderers-0.1.8.dev44}/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.dev42'
-__version_tuple__ = version_tuple = (0, 1, 8, 'dev42')
+__version__ = version = '0.1.8.dev44'
+__version_tuple__ = version_tuple = (0, 1, 8, 'dev44')
 
 __commit_id__ = commit_id = None

{renderers-0.1.8.dev42 → renderers-0.1.8.dev44}/renderers/base.py

@@ -1030,21 +1030,25 @@ MODEL_RENDERER_MAP: dict[str, str] = {
     # MiniMax.
     "MiniMaxAI/MiniMax-M2": "minimax-m2",
     "MiniMaxAI/MiniMax-M2.5": "minimax-m2",
-    # DeepSeek V3.
+    # DeepSeek V3 (non-reasoning).
     "deepseek-ai/DeepSeek-V3": "deepseek-v3",
     "deepseek-ai/DeepSeek-V3-Base": "deepseek-v3",
+    # DeepSeek R1 (reasoning).
+    "deepseek-ai/DeepSeek-R1": "deepseek-r1",
+    "deepseek-ai/DeepSeek-R1-0528": "deepseek-r1",
     # Kimi K2 (K2.5 and K2.6 share the K2.5 template, distinct from K2).
     "moonshotai/Kimi-K2-Instruct": "kimi-k2",
     "moonshotai/Kimi-K2.5": "kimi-k2.5",
     "moonshotai/Kimi-K2.6": "kimi-k2.5",
-    # Nemotron 3. Nano / Super share one chat-template variant; the Ultra
-    # checkpoints use the Ultra variant — the renderer auto-selects it from
-    # the model name (see ``nemotron3._ULTRA_DEFAULTS``). BF16 and FP8 share the
+    # Nemotron 3. Nano / Super share one chat-template variant (``nemotron-3``);
+    # the Ultra checkpoints use the Ultra variant (``nemotron-3-ultra``, distinct
+    # ``</think>`` glue). Both route to the same Nemotron3Renderer, which selects
+    # the variant from the resolved config's ``name``. BF16 and FP8 share the
     # same tokenizer and template.
     "nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16": "nemotron-3",
     "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16": "nemotron-3",
-    "nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B-BF16": "nemotron-3",
-    "nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B-FP8": "nemotron-3",
+    "nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B-BF16": "nemotron-3-ultra",
+    "nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B-FP8": "nemotron-3-ultra",
     # Llama 3.2 (Instruct). Tested against the gated meta-llama repos and
     # the unrestricted unsloth/... mirror, which ships a byte-identical
     # chat template. ``Llama3Renderer`` defaults ``date_string`` to
@@ -1161,6 +1165,8 @@ FASTOKENS_INCOMPATIBLE: frozenset[str] = frozenset(
         # doesn't yet implement.
         "deepseek-ai/DeepSeek-V3",
         "deepseek-ai/DeepSeek-V3-Base",
+        "deepseek-ai/DeepSeek-R1",
+        "deepseek-ai/DeepSeek-R1-0528",
     }
 )
 
@@ -1334,6 +1340,7 @@ def load_tokenizer(
 def _populate_registry():
     if RENDERER_REGISTRY:
         return
+    from renderers.deepseek_r1 import DeepSeekR1Renderer
     from renderers.deepseek_v3 import DeepSeekV3Renderer
     from renderers.default import DefaultRenderer
     from renderers.glm5 import GLM5Renderer, GLM51Renderer
@@ -1344,7 +1351,7 @@ def _populate_registry():
     from renderers.laguna_xs2 import LagunaXS2Renderer
     from renderers.llama_3 import Llama3Renderer
     from renderers.minimax_m2 import MiniMaxM2Renderer
-    from renderers.nemotron3 import Nemotron3Renderer
+    from renderers.nemotron3 import Nemotron3Renderer, Nemotron3UltraRenderer
     from renderers.qwen3 import Qwen3Renderer
     from renderers.qwen3_vl import Qwen3VLRenderer
     from renderers.qwen35 import Qwen35Renderer
@@ -1362,11 +1369,13 @@ def _populate_registry():
             "glm-4.5": GLM45Renderer,
             "minimax-m2": MiniMaxM2Renderer,
             "deepseek-v3": DeepSeekV3Renderer,
+            "deepseek-r1": DeepSeekR1Renderer,
             "kimi-k2": KimiK2Renderer,
             "kimi-k2.5": KimiK25Renderer,
             "laguna-xs.2": LagunaXS2Renderer,
             "llama-3": Llama3Renderer,
             "nemotron-3": Nemotron3Renderer,
+            "nemotron-3-ultra": Nemotron3UltraRenderer,
             "gpt-oss": GptOssRenderer,
         }
     )

{renderers-0.1.8.dev42 → renderers-0.1.8.dev44}/renderers/configs.py

@@ -354,7 +354,14 @@ class MiniMaxM2RendererConfig(BaseRendererConfig):
 
 
 class Nemotron3RendererConfig(BaseRendererConfig):
-    """Nemotron 3 renderer config."""
+    """Nemotron-3 **Nano / Super** renderer config.
+
+    Nano and Super share one chat-template variant; the renderer routes both
+    through :class:`renderers.nemotron3.Nemotron3Renderer`. The Ultra variant
+    has its own template (different reasoning-block glue) and config —
+    :class:`Nemotron3UltraRendererConfig` — and is reached via the
+    ``nemotron-3-ultra`` discriminator.
+    """
 
     name: Literal["nemotron-3"] = "nemotron-3"
 
@@ -362,26 +369,6 @@ class Nemotron3RendererConfig(BaseRendererConfig):
     """When ``True``, the generation prompt includes ``<think>``. Mirrors
     the chat template's ``enable_thinking`` kwarg."""
 
-    ultra: bool | None = None
-    """Select the Nemotron-3 **Ultra** chat-template variant.
-
-    ``None`` (default) auto-detects from the model name (see
-    ``renderers.nemotron3._ULTRA_DEFAULTS``): the Ultra checkpoints resolve
-    to ``True``; Nano / Super and unknown checkpoints to ``False``. Set
-    explicitly to force a variant — e.g. an Ultra fine-tune or a
-    locally-pathed checkpoint whose ``name_or_path`` isn't in the table.
-
-    Ultra's template differs from Nano/Super: the reasoning block is glued
-    as ``<think>\\n{reasoning}</think>{content}`` (no ``\\n`` around
-    ``</think>``), truncated historical turns collapse to
-    ``<think></think>{content}`` (no ``\\n``), and the thinking-truncation
-    boundary follows the template's ``loop.index0 < last_user_idx`` rule
-    (drop thinking on every assistant turn before the last user message).
-
-    Not a chat-template kwarg — it picks which template the renderer
-    mirrors, not a variable passed into one — so it's listed in
-    ``_internal_fields`` and excluded from ``template_field_names()``."""
-
     truncate_history_thinking: bool = True
     """When ``False``, keep ``<think>{reasoning}</think>`` on past-cycle
     assistant turns instead of dropping them. Mirrors the chat
@@ -389,35 +376,64 @@ class Nemotron3RendererConfig(BaseRendererConfig):
     ``preserve_all_thinking`` / ``preserve_thinking_between_tool_calls``
     — see :class:`BaseRendererConfig` for the contract."""
 
-    # ``ultra`` is a template-variant SELECTOR — it picks which template the
-    # renderer mirrors (Ultra vs Nano/Super), not a variable passed into one;
-    # there is no ``ultra`` Jinja variable. Marked internal so the parity
-    # matrix doesn't cross it as a template field. Same ``_internal_fields``
-    # mechanism DeepSeek-V3 uses for its no-op ``enable_thinking``, for a
-    # different underlying reason (theirs is an ignored kwarg, this is a
-    # variant switch).
-    _internal_fields = frozenset({"ultra"})
+    low_effort: bool = False
+    """When ``True``, append ``\\n\\n{reasoning effort: low}`` to the last user
+    message, nudging the model toward shorter reasoning. Mirrors the **Super**
+    chat template's ``low_effort`` kwarg. A no-op on **Nano** (its template
+    doesn't define it) — exactly as ``apply_chat_template`` ignores an undefined
+    template variable; the renderer distinguishes the two by model name (see
+    ``renderers.nemotron3._is_super``)."""
+
+
+class Nemotron3UltraRendererConfig(BaseRendererConfig):
+    """Nemotron-3 **Ultra** renderer config — distinct discriminator so the
+    registry routes Ultra checkpoints to the Ultra template variant.
+
+    Ultra's template differs from Nano/Super: the reasoning block is glued as
+    ``<think>\\n{reasoning}</think>{content}`` (no ``\\n`` around ``</think>``)
+    and truncated historical turns collapse to ``<think></think>{content}``
+    (no ``\\n``). It shares the :class:`renderers.nemotron3.Nemotron3Renderer`
+    implementation, which selects the variant from ``config.name``.
+    """
+
+    name: Literal["nemotron-3-ultra"] = "nemotron-3-ultra"
+
+    enable_thinking: bool = True
+    """See :class:`Nemotron3RendererConfig.enable_thinking`."""
+
+    truncate_history_thinking: bool = True
+    """See :class:`Nemotron3RendererConfig.truncate_history_thinking`."""
+
+    medium_effort: bool = False
+    """When ``True``, append ``\\n\\n{reasoning effort: efficient}`` to the last
+    user message. Mirrors the Ultra chat template's ``medium_effort`` kwarg."""
 
 
 class DeepSeekV3RendererConfig(BaseRendererConfig):
-    """DeepSeek V3 renderer config.
+    """DeepSeek-V3 renderer config (non-reasoning).
 
-    ``enable_thinking`` is renderer-internal here — DeepSeek-V3's chat
-    template does not reference any thinking variable, so passing it to
-    ``apply_chat_template`` upstream is a no-op. The renderer uses it
-    to control the ``<think>`` prefill at the generation prompt (R1
-    distill convention).
+    DeepSeek-V3 has no thinking concept: the generation prompt is a bare
+    ``<｜Assistant｜>`` and assistant content is emitted verbatim. For the
+    reasoning variant use :class:`DeepSeekR1RendererConfig`.
     """
 
     name: Literal["deepseek-v3"] = "deepseek-v3"
 
-    enable_thinking: bool = True
-    """Renderer convention for the R1-distill family: when ``True``,
-    prefill ``<think>`` at the generation prompt. The DeepSeek-V3 Jinja
-    template ignores this kwarg upstream; it's not a chat-template
-    kwarg in the strict sense."""
 
-    _internal_fields = frozenset({"enable_thinking"})
+class DeepSeekR1RendererConfig(BaseRendererConfig):
+    """DeepSeek-R1 renderer config (reasoning).
+
+    R1 always reasons — its chat template unconditionally prefills
+    ``<think>\\n`` at the generation prompt and strips ``</think>`` from
+    historical assistant turns. There is therefore no ``enable_thinking``
+    knob (thinking is not optional), and ``preserve_*`` flags are no-ops
+    (history reasoning is always dropped); both stored for protocol
+    uniformity. Applies to full ``deepseek-ai/DeepSeek-R1`` / ``-R1-0528``
+    — NOT the R1-Distill-Qwen/Llama models, which use those base
+    tokenizers and route to the Qwen3 / Llama-3 renderers.
+    """
+
+    name: Literal["deepseek-r1"] = "deepseek-r1"
 
 
 RendererConfig = Annotated[
@@ -438,7 +454,9 @@ RendererConfig = Annotated[
         Llama3RendererConfig,
         MiniMaxM2RendererConfig,
         Nemotron3RendererConfig,
+        Nemotron3UltraRendererConfig,
         DeepSeekV3RendererConfig,
+        DeepSeekR1RendererConfig,
     ],
     Field(discriminator="name"),
 ]
@@ -473,7 +491,9 @@ _CONFIG_BY_NAME: dict[str, type[BaseRendererConfig]] = {
     "llama-3": Llama3RendererConfig,
     "minimax-m2": MiniMaxM2RendererConfig,
     "nemotron-3": Nemotron3RendererConfig,
+    "nemotron-3-ultra": Nemotron3UltraRendererConfig,
     "deepseek-v3": DeepSeekV3RendererConfig,
+    "deepseek-r1": DeepSeekR1RendererConfig,
 }
 
 
@@ -505,6 +525,7 @@ __all__ = [
     "AutoRendererConfig",
     "BaseRendererConfig",
     "DefaultRendererConfig",
+    "DeepSeekR1RendererConfig",
     "DeepSeekV3RendererConfig",
     "GLM45RendererConfig",
     "GLM51RendererConfig",
@@ -516,6 +537,7 @@ __all__ = [
     "Llama3RendererConfig",
     "MiniMaxM2RendererConfig",
     "Nemotron3RendererConfig",
+    "Nemotron3UltraRendererConfig",
     "Qwen35RendererConfig",
     "Qwen36RendererConfig",
     "Qwen3RendererConfig",

renderers-0.1.8.dev44/renderers/deepseek_r1.py

@@ -0,0 +1,58 @@
+"""DeepSeek-R1 Renderer — the reasoning variant of the DeepSeek format.
+
+R1 shares DeepSeek-V3's special tokens, message structure, and tool-call
+wire format, so it subclasses :class:`renderers.deepseek_v3.DeepSeekV3Renderer`
+and overrides only the two places its chat template diverges:
+
+1. Generation prompt — R1 unconditionally prefills ``<think>\\n``
+   (``<｜Assistant｜><think>\\n``) to trigger reasoning, where V3 emits a bare
+   ``<｜Assistant｜>``. Handled by ``_GEN_THINK_PREFILL``.
+2. Historical assistant turns — R1 strips the reasoning trace, keeping only
+   the text after ``</think>`` (``content.split('</think>')[-1]``), where V3
+   emits content verbatim. Handled by ``_prepare_assistant_content``.
+
+Everything else — system handling, tool-call / tool-output rendering,
+special-token resolution, and ``parse_response`` (``parse_deepseek_v3``,
+shared) — is inherited unchanged.
+
+Scope: full ``deepseek-ai/DeepSeek-R1`` and ``-R1-0528``. The R1-Distill
+models (``DeepSeek-R1-Distill-Qwen/Llama``) use their base models'
+tokenizers and route to the Qwen3 / Llama-3 renderers, not this one.
+"""
+
+from __future__ import annotations
+
+from renderers.base import Message
+from renderers.configs import DeepSeekR1RendererConfig
+from renderers.deepseek_v3 import DeepSeekV3Renderer
+
+
+class DeepSeekR1Renderer(DeepSeekV3Renderer):
+    """Deterministic message → token renderer for DeepSeek-R1 models."""
+
+    _config_cls: type = DeepSeekR1RendererConfig
+    _GEN_THINK_PREFILL: str = "<think>\n"
+
+    def _prepare_assistant_content(self, msg: Message) -> str:
+        """Assistant content with the reasoning trace stripped, mirroring the
+        R1 template's ``content.split('</think>')[-1]`` on historical turns.
+
+        Structured ``thinking``/``text`` parts are reconstructed inline first
+        so the same ``</think>`` split applies. The separate
+        ``reasoning_content`` field is ignored — the R1 chat template never
+        reads it, and history reasoning is dropped regardless.
+        """
+        content = msg.get("content") or ""
+        if isinstance(content, list):
+            parts: list[str] = []
+            for p in content:
+                if not isinstance(p, dict):
+                    continue
+                if p.get("type") == "thinking":
+                    parts.append(f"<think>{p.get('thinking', '')}</think>")
+                elif p.get("type") == "text":
+                    parts.append(p.get("text", ""))
+            content = "".join(parts)
+        if "</think>" in content:
+            content = content.split("</think>")[-1]
+        return content

{renderers-0.1.8.dev42 → renderers-0.1.8.dev44}/renderers/deepseek_v3.py

@@ -41,25 +41,30 @@ def _ds_token(name: str) -> str:
 
 
 class DeepSeekV3Renderer:
-    """Deterministic message → token renderer for DeepSeek V3 models.
-
-    DeepSeek-V3's chat template does not consult any thinking-related
-    variable; the ``enable_thinking`` field on the typed config controls
-    the renderer's ``<think>\\n`` prefill at the generation prompt
-    (R1-distill convention) and is intentionally not forwarded to
-    ``apply_chat_template`` upstream — that would be a no-op. The
-    template also always emits ``<think>{reasoning}</think>`` when
-    ``reasoning_content`` is provided, so ``preserve_*`` flags are
-    no-ops here too; stored for protocol uniformity.
+    """Deterministic message → token renderer for DeepSeek-V3 models.
+
+    DeepSeek-V3 is non-reasoning: its chat template has no ``<think>``
+    concept — the generation prompt is a bare ``<｜Assistant｜>`` and past
+    assistant content is emitted verbatim. The reasoning variant
+    (``<think>``-prefilled prompt, history reasoning stripped) lives in
+    :class:`renderers.deepseek_r1.DeepSeekR1Renderer`, which subclasses
+    this one. ``preserve_*`` flags are no-ops here (no reasoning channel),
+    stored for protocol uniformity.
     """
 
+    #: Default typed config; the R1 subclass overrides this.
+    _config_cls: type = DeepSeekV3RendererConfig
+    #: Generation-prompt reasoning prefill. Empty for V3 (bare
+    #: ``<｜Assistant｜>``); the R1 subclass overrides to ``"<think>\n"``.
+    _GEN_THINK_PREFILL: str = ""
+
     def __init__(
         self,
         tokenizer: PreTrainedTokenizer,
         config: DeepSeekV3RendererConfig | None = None,
     ):
         self._tokenizer = tokenizer
-        self.config = config or DeepSeekV3RendererConfig()
+        self.config = config or type(self)._config_cls()
 
         # ── BOS / EOS ────────────────────────────────────────────────
         self._bos = self._get_special_token(f"begin{_US}of{_US}sentence")
@@ -239,8 +244,10 @@ class DeepSeekV3Renderer:
                 emit_special(
                     self._assistant_token, -1, is_sampled=False, is_content=False
                 )
-            if self.config.enable_thinking:
-                emit_text("<think>\n", -1, is_sampled=False, is_content=False)
+            if self._GEN_THINK_PREFILL:
+                emit_text(
+                    self._GEN_THINK_PREFILL, -1, is_sampled=False, is_content=False
+                )
 
         return RenderedTokens(
             token_ids=tokens,
@@ -382,8 +389,8 @@ class DeepSeekV3Renderer:
         last_role = new_messages[-1].get("role") if new_messages else None
         if last_role != "tool":
             emit_special(self._assistant_token, -1)
-        if self.config.enable_thinking:
-            emit_text("<think>\n", -1)
+        if self._GEN_THINK_PREFILL:
+            emit_text(self._GEN_THINK_PREFILL, -1)
 
         total_len = len(previous_ids) + len(ext)
         return RenderedTokens(
@@ -399,6 +406,23 @@ class DeepSeekV3Renderer:
     # Assistant rendering
     # ------------------------------------------------------------------
 
+    def _prepare_assistant_content(self, msg: Message) -> str:
+        """Assistant content as the V3 template would emit it: verbatim.
+
+        V3 is non-reasoning — its template emits ``message['content']`` as-is
+        and never reads ``reasoning_content``. A structured content list is
+        flattened to its ``text`` parts. The R1 subclass overrides this to
+        strip ``</think>`` from history.
+        """
+        content = msg.get("content") or ""
+        if isinstance(content, list):
+            content = "".join(
+                p.get("text", "")
+                for p in content
+                if isinstance(p, dict) and p.get("type") == "text"
+            )
+        return content
+
     def _render_assistant(
         self,
         msg: Message,
@@ -414,24 +438,7 @@ class DeepSeekV3Renderer:
         # without a new <｜Assistant｜> token in that case.
         prev_is_tool = msg_idx > 0 and messages[msg_idx - 1]["role"] == "tool"
 
-        content = msg.get("content") or ""
-        # Support structured content (ThinkingPart / TextPart list).
-        if isinstance(content, list):
-            parts_text: list[str] = []
-            for p in content:
-                if not isinstance(p, dict):
-                    continue
-                if p.get("type") == "thinking":
-                    thinking = p.get("thinking", "")
-                    parts_text.append(f"<think>{thinking}</think>")
-                elif p.get("type") == "text":
-                    parts_text.append(p.get("text", ""))
-            content = "".join(parts_text)
-        # Also accept reasoning_content stored separately (OpenAI-style).
-        elif isinstance(msg.get("reasoning_content"), str) and msg["reasoning_content"]:
-            reasoning = msg["reasoning_content"]
-            content = f"<think>{reasoning}</think>{content}"
-
+        content = self._prepare_assistant_content(msg)
         tool_calls = msg.get("tool_calls") or []
 
         # ``<｜Assistant｜>`` is template-injected scaffolding — at