renderers 0.1.12.dev4__tar.gz → 0.1.12.dev6__tar.gz

{renderers-0.1.12.dev4 → renderers-0.1.12.dev6}/.github/workflows/test.yml

@@ -21,7 +21,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.10", "3.11", "3.12", "3.13"]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
 
     steps:
       - uses: actions/checkout@v4

{renderers-0.1.12.dev4 → renderers-0.1.12.dev6}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.5
 Name: renderers
-Version: 0.1.12.dev4
+Version: 0.1.12.dev6
 Summary: Chat template renderers — deterministic message-to-token conversion for LLM training
 License-Expression: Apache-2.0
 License-File: LICENSE
-Requires-Python: <3.14,>=3.10
+Requires-Python: <3.15,>=3.10
 Requires-Dist: jinja2
 Requires-Dist: numpy
 Requires-Dist: openai-harmony>=0.0.4
@@ -106,7 +106,7 @@ next_prompt_ids = r.bridge_to_next_turn(
 )
 ```
 
-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`, `deepseek-v4` (V4 Flash 0731), `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).
+Hand-coded renderers ship for `qwen3`, `qwen3-vl`, `qwen3.5`, `qwen3.6`, `qwen3.8`, `gemma4`, `glm-5`, `glm-5.1`, `glm-5.3`, `glm-4.5`, `minimax-m2`, `deepseek-v3`, `deepseek-r1`, `deepseek-v4` (V4 Flash 0731), `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.12.dev4 → renderers-0.1.12.dev6}/README.md

@@ -86,7 +86,7 @@ next_prompt_ids = r.bridge_to_next_turn(
 )
 ```
 
-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`, `deepseek-v4` (V4 Flash 0731), `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).
+Hand-coded renderers ship for `qwen3`, `qwen3-vl`, `qwen3.5`, `qwen3.6`, `qwen3.8`, `gemma4`, `glm-5`, `glm-5.1`, `glm-5.3`, `glm-4.5`, `minimax-m2`, `deepseek-v3`, `deepseek-r1`, `deepseek-v4` (V4 Flash 0731), `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.12.dev4 → renderers-0.1.12.dev6}/docs/renderer-config.md

@@ -34,6 +34,7 @@ product in `tests/test_parity.py`.
 | 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` | - |
+| GLM-5.3 | `GLM53RendererConfig` | `clear_thinking`, `reasoning_effort` | - |
 | GLM-4.5 | `GLM45RendererConfig` | `enable_thinking` | - |
 | gpt-oss | `GptOssRendererConfig` | `reasoning_effort`, `conversation_start_date` | `use_system_prompt`, `knowledge_cutoff`, `model_identity`, `auto_drop_analysis` |
 | Hy3 | `Hy3RendererConfig` | `reasoning_effort`, `preserved_thinking`, `is_training`, `raw_last_assistant`, `fallback_strategy` | - |
@@ -140,6 +141,7 @@ the knobs its template actually exposes:
 | 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-5.3 | `clear_thinking=False -> all`, else `tool_cycle` |
 | GLM-4.5 | `enable_thinking=False -> all`, else `tool_cycle` |
 | gpt-oss | `auto_drop_analysis=False -> all`, else `tool_cycle` |
 | Hy3 | `preserved_thinking=True -> all`, else `tool_cycle` |

{renderers-0.1.12.dev4 → renderers-0.1.12.dev6}/pyproject.toml

@@ -13,7 +13,7 @@ description = "Chat template renderers — deterministic message-to-token conver
 readme = "README.md"
 license = "Apache-2.0"
 license-files = ["LICENSE"]
-requires-python = ">=3.10,<3.14"
+requires-python = ">=3.10,<3.15"
 dependencies = [
     "numpy",
     "openai>=1.108.1",

{renderers-0.1.12.dev4 → renderers-0.1.12.dev6}/renderers/__init__.py

@@ -7,11 +7,11 @@ except ImportError:
     __version__ = "0+unknown"
 
 from renderers.base import (
+    MULTIMODAL_MODELS,
     ChatTemplateTokenizer,
     Content,
     ContentPart,
     ImagePart,
-    MULTIMODAL_MODELS,
     Message,
     MultiModalData,
     MultimodalRenderer,
@@ -44,36 +44,37 @@ from renderers.client import MalformedGenerateResponseError, OverlongPromptError
 from renderers.configs import (
     AutoRendererConfig,
     BaseRendererConfig,
-    config_from_name,
-    DefaultRendererConfig,
     DeepSeekR1RendererConfig,
     DeepSeekV3RendererConfig,
     DeepSeekV4RendererConfig,
+    DefaultRendererConfig,
+    Gemma4RendererConfig,
+    GLM5RendererConfig,
     GLM45RendererConfig,
     GLM51RendererConfig,
-    GLM5RendererConfig,
-    Gemma4RendererConfig,
+    GLM53RendererConfig,
     GptOssRendererConfig,
     Hy3RendererConfig,
     InklingRendererConfig,
-    KimiK25RendererConfig,
     KimiK2RendererConfig,
+    KimiK25RendererConfig,
     LagunaM1RendererConfig,
     LagunaS21RendererConfig,
     LagunaXS2RendererConfig,
     LagunaXS21RendererConfig,
     Llama3RendererConfig,
     MiniMaxM2RendererConfig,
-    Nemotron35RendererConfig,
     Nemotron3RendererConfig,
     Nemotron3UltraRendererConfig,
+    Nemotron35RendererConfig,
     PrimeQwen3RendererConfig,
+    Qwen3RendererConfig,
+    Qwen3VLRendererConfig,
     Qwen35RendererConfig,
     Qwen36RendererConfig,
     Qwen38RendererConfig,
-    Qwen3RendererConfig,
-    Qwen3VLRendererConfig,
     RendererConfig,
+    config_from_name,
 )
 
 # Concrete renderer classes are lazy-loaded so that consumers needing only the
@@ -90,6 +91,7 @@ _LAZY_RENDERERS: dict[str, str] = {
     "DefaultRenderer": "renderers.default",
     "GLM45Renderer": "renderers.glm45",
     "GLM51Renderer": "renderers.glm5",
+    "GLM53Renderer": "renderers.glm5",
     "GLM5Renderer": "renderers.glm5",
     "GptOssRenderer": "renderers.gpt_oss",
     "Gemma4Renderer": "renderers.gemma4",
@@ -148,6 +150,8 @@ __all__ = [
     "GLM45RendererConfig",
     "GLM51Renderer",
     "GLM51RendererConfig",
+    "GLM53Renderer",
+    "GLM53RendererConfig",
     "GLM5Renderer",
     "GLM5RendererConfig",
     "Gemma4Renderer",

{renderers-0.1.12.dev4 → renderers-0.1.12.dev6}/renderers/_version.py

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

{renderers-0.1.12.dev4 → renderers-0.1.12.dev6}/renderers/base.py

@@ -984,6 +984,8 @@ MODEL_RENDERER_MAP: dict[str, str] = {
     "zai-org/GLM-5-FP8": "glm-5",
     "zai-org/GLM-4.7-Flash": "glm-5",
     "zai-org/GLM-5.1": "glm-5.1",
+    "zai-org/GLM-5.3": "glm-5.3",
+    "zai-org/GLM-5.3-BF16": "glm-5.3",
     # GLM-4.5.
     "THUDM/GLM-4.5-Air": "glm-4.5",
     "zai-org/GLM-4.5-Air": "glm-4.5",
@@ -1318,10 +1320,10 @@ def _populate_registry():
     from renderers.deepseek_v3 import DeepSeekV3Renderer
     from renderers.deepseek_v4 import DeepSeekV4Renderer
     from renderers.default import DefaultRenderer
-    from renderers.glm5 import GLM5Renderer, GLM51Renderer
+    from renderers.gemma4 import Gemma4Renderer
+    from renderers.glm5 import GLM5Renderer, GLM51Renderer, GLM53Renderer
     from renderers.glm45 import GLM45Renderer
     from renderers.gpt_oss import GptOssRenderer
-    from renderers.gemma4 import Gemma4Renderer
     from renderers.hy3 import Hy3Renderer
     from renderers.inkling import InklingRenderer
     from renderers.kimi_k2 import KimiK2Renderer
@@ -1358,6 +1360,7 @@ def _populate_registry():
             "qwen3.8": Qwen38Renderer,
             "glm-5": GLM5Renderer,
             "glm-5.1": GLM51Renderer,
+            "glm-5.3": GLM53Renderer,
             "glm-4.5": GLM45Renderer,
             "minimax-m2": MiniMaxM2Renderer,
             "deepseek-v3": DeepSeekV3Renderer,

{renderers-0.1.12.dev4 → renderers-0.1.12.dev6}/renderers/configs.py

@@ -411,6 +411,29 @@ class GLM51RendererConfig(BaseRendererConfig):
         return self
 
 
+class GLM53RendererConfig(BaseRendererConfig):
+    """GLM-5.3 renderer config."""
+
+    name: Literal["glm-5.3"] = "glm-5.3"
+    _template_fields = frozenset({"clear_thinking", "reasoning_effort"})
+
+    clear_thinking: bool = False
+    """Drop reasoning from historical assistant turns when ``True``."""
+
+    reasoning_effort: Literal["low", "high", "max"] = "max"
+    """Reasoning-effort system preamble emitted by the canonical template."""
+
+    @model_validator(mode="after")
+    def _check_thinking_retention(self):
+        _reject_thinking_retention_conflict(
+            self,
+            "clear_thinking",
+            true_implies="tool_cycle",
+            false_implies="all",
+        )
+        return self
+
+
 class GLM45RendererConfig(BaseRendererConfig):
     """GLM-4.5 Air renderer config."""
 
@@ -984,6 +1007,7 @@ RendererConfig = Annotated[
         Gemma4RendererConfig,
         GLM5RendererConfig,
         GLM51RendererConfig,
+        GLM53RendererConfig,
         GLM45RendererConfig,
         GptOssRendererConfig,
         Hy3RendererConfig,
@@ -1031,6 +1055,7 @@ _CONFIG_BY_NAME: dict[str, type[BaseRendererConfig]] = {
     "gemma4": Gemma4RendererConfig,
     "glm-5": GLM5RendererConfig,
     "glm-5.1": GLM51RendererConfig,
+    "glm-5.3": GLM53RendererConfig,
     "glm-4.5": GLM45RendererConfig,
     "gpt-oss": GptOssRendererConfig,
     "hy3": Hy3RendererConfig,
@@ -1056,8 +1081,7 @@ def _config_class_for(name: str) -> type[BaseRendererConfig]:
     cls = _CONFIG_BY_NAME.get(name)
     if cls is None:
         raise ValueError(
-            f"No renderer config registered for name={name!r}. "
-            f"Known: {sorted(_CONFIG_BY_NAME)}"
+            f"No renderer config registered for name={name!r}. Known: {sorted(_CONFIG_BY_NAME)}"
         )
     return cls
 
@@ -1085,6 +1109,7 @@ __all__ = [
     "DeepSeekV4RendererConfig",
     "GLM45RendererConfig",
     "GLM51RendererConfig",
+    "GLM53RendererConfig",
     "GLM5RendererConfig",
     "Gemma4RendererConfig",
     "GptOssRendererConfig",

{renderers-0.1.12.dev4 → renderers-0.1.12.dev6}/renderers/glm5.py

@@ -20,8 +20,8 @@ from renderers.base import (
     Message,
     ParsedResponse,
     RenderedTokens,
-    ToolSpec,
     Tokenizer,
+    ToolSpec,
     _content_mask_or_empty,
     attribute_text_segments,
     extract_message_tool_names,
@@ -29,7 +29,11 @@ from renderers.base import (
     resolve_thinking_retention,
     should_rerender_for_thinking_retention,
 )
-from renderers.configs import GLM5RendererConfig, GLM51RendererConfig
+from renderers.configs import (
+    GLM5RendererConfig,
+    GLM51RendererConfig,
+    GLM53RendererConfig,
+)
 from renderers.parsing import parse_glm
 
 _TOOLS_HEADER = (
@@ -73,7 +77,7 @@ class GLM5Renderer:
         self.config = config or type(self)._config_cls()
         if not self.config.clear_thinking:
             implied_thinking_retention = "all"
-        elif not self.config.enable_thinking:
+        elif not getattr(self.config, "enable_thinking", True):
             implied_thinking_retention = "all"
         else:
             implied_thinking_retention = "tool_cycle"
@@ -262,14 +266,20 @@ class GLM5Renderer:
                 )
 
             elif role == "tool":
-                self._render_tool(
-                    messages,
-                    i,
-                    content,
-                    emit_special=emit_special,
-                    emit_text=emit_text,
-                    emit_text_segments=emit_text_segments,
-                )
+                if i == 0 or messages[i - 1]["role"] != "tool":
+                    for position, tool_idx in enumerate(
+                        self._ordered_tool_indices(messages, i)
+                    ):
+                        tool_message = messages[tool_idx]
+                        self._render_tool(
+                            messages,
+                            tool_idx,
+                            self._visible_text(tool_message.get("content")),
+                            emit_special=emit_special,
+                            emit_text=emit_text,
+                            emit_text_segments=emit_text_segments,
+                            starts_block=position == 0,
+                        )
 
         # ── Generation prompt ───────────────────────────────────────
         # Gen prompt tokens are what the chat template prepends before
@@ -277,7 +287,7 @@ class GLM5Renderer:
         # them. Always is_sampled=False / is_content=False.
         if add_generation_prompt:
             emit_special(self._assistant, -1, is_sampled=False, is_content=False)
-            if self.config.enable_thinking:
+            if getattr(self.config, "enable_thinking", True):
                 emit_special(self._think, -1, is_sampled=False, is_content=False)
             else:
                 emit_special(self._think_end, -1, is_sampled=False, is_content=False)
@@ -291,6 +301,17 @@ class GLM5Renderer:
             message_tool_names=extract_message_tool_names(messages),
         )
 
+    @staticmethod
+    def _ordered_tool_indices(messages: list[Message], block_start: int) -> list[int]:
+        """Return one contiguous tool block in its source order."""
+        block_end = block_start
+        while (
+            block_end + 1 < len(messages)
+            and messages[block_end + 1].get("role") == "tool"
+        ):
+            block_end += 1
+        return list(range(block_start, block_end + 1))
+
     def render_ids(
         self,
         messages: list[Message],
@@ -478,7 +499,7 @@ class GLM5Renderer:
 
         # Generation prompt — match the gen-prompt branch of ``render()``.
         emit_special(self._assistant, -1)
-        if self.config.enable_thinking:
+        if getattr(self.config, "enable_thinking", True):
             emit_special(self._think, -1)
         else:
             emit_special(self._think_end, -1)
@@ -632,6 +653,7 @@ class GLM5Renderer:
         emit_special,
         emit_text,
         emit_text_segments,
+        starts_block: bool = False,
     ) -> None:
         # Tool body bytes get ``is_content=True``; the wraps are
         # scaffold. The ``<|observation|>`` role tag is scaffold too
@@ -644,7 +666,7 @@ class GLM5Renderer:
         prev_role = messages[msg_idx - 1]["role"] if msg_idx > 0 else None
         closes_assistant_turn = prev_role == "assistant"
 
-        if prev_role != "tool":
+        if starts_block or prev_role != "tool":
             emit_special(
                 self._observation,
                 msg_idx,
@@ -683,3 +705,165 @@ class GLM51Renderer(GLM5Renderer):
         spec = tool["function"] if "function" in tool else tool
         spec = {k: v for k, v in spec.items() if k not in ("defer_loading", "strict")}
         return json.dumps(spec, ensure_ascii=False)
+
+
+class GLM53Renderer(GLM5Renderer):
+    """Deterministic message → token renderer for GLM-5.3 models.
+
+    GLM-5.3 adds a reasoning-effort system preamble and always starts an
+    assistant generation with ``<think>``.  Its template also orders a tool
+    result block by the preceding assistant's tool-call IDs.
+    """
+
+    _config_cls = GLM53RendererConfig
+
+    @staticmethod
+    def _visible_text(content: Any) -> str:
+        # The GLM-5.3 template omits ``None`` content instead of rendering
+        # Python's string representation (notably tool-call-only assistants).
+        return "" if content is None else GLM5Renderer._visible_text(content)
+
+    def __init__(
+        self,
+        tokenizer: Tokenizer,
+        config: GLM53RendererConfig | None = None,
+    ):
+        super().__init__(tokenizer, config)
+        self.effective_thinking_retention = resolve_thinking_retention(
+            self.config,
+            "tool_cycle" if self.config.clear_thinking else "all",
+        )
+
+    @staticmethod
+    def _format_tool_spec(tool: ToolSpec) -> str:
+        spec = tool["function"] if "function" in tool else tool
+        spec = {k: v for k, v in spec.items() if k not in ("defer_loading", "strict")}
+        return json.dumps(spec, ensure_ascii=False)
+
+    def _ordered_tool_indices(
+        self, messages: list[Message], block_start: int
+    ) -> list[int]:
+        """Match the template's safe tool-result reordering rule."""
+        block_end = block_start
+        while (
+            block_end + 1 < len(messages)
+            and messages[block_end + 1].get("role") == "tool"
+        ):
+            block_end += 1
+
+        previous = messages[block_start - 1] if block_start else {}
+        calls = (
+            previous.get("tool_calls") if previous.get("role") == "assistant" else None
+        )
+        if not calls:
+            return list(range(block_start, block_end + 1))
+
+        call_ids = [call.get("id") or call.get("tool_call_id") for call in calls]
+        result_ids = [
+            message.get("tool_call_id") or message.get("id")
+            for message in messages[block_start : block_end + 1]
+        ]
+        if (
+            any(identifier is None for identifier in call_ids + result_ids)
+            or len(set(call_ids)) != len(call_ids)
+            or len(set(result_ids)) != len(result_ids)
+            or set(call_ids) != set(result_ids)
+        ):
+            return list(range(block_start, block_end + 1))
+
+        by_id = {
+            identifier: index
+            for identifier, index in zip(result_ids, range(block_start, block_end + 1))
+        }
+        return [by_id[identifier] for identifier in call_ids]
+
+    def render(
+        self,
+        messages: list[Message],
+        *,
+        tools: list[ToolSpec] | None = None,
+        add_generation_prompt: bool = False,
+    ) -> RenderedTokens:
+        rendered = super().render(
+            messages, tools=tools, add_generation_prompt=add_generation_prompt
+        )
+        # GLM-5.3's preamble belongs immediately after ``[gMASK]<sop>``.
+        prefix = [self._gmask, self._sop]
+        preamble = [self._system] + self._encode(
+            f"Reasoning Effort: {self.config.reasoning_effort.capitalize()}"
+        )
+        assert rendered.token_ids[:2] == prefix
+        insertion = len(prefix)
+        rendered.token_ids[insertion:insertion] = preamble
+        rendered.message_indices[insertion:insertion] = [-1] * len(preamble)
+        rendered.sampled_mask[insertion:insertion] = [False] * len(preamble)
+        if rendered.is_content:
+            rendered.is_content[insertion:insertion] = [False] * len(preamble)
+        return rendered
+
+    def _render_assistant(
+        self,
+        msg,
+        msg_idx,
+        content,
+        last_user_index,
+        *,
+        emit_special,
+        emit_text,
+        emit_text_segments,
+    ):
+        reasoning_content = ""
+        has_reasoning = False
+        if isinstance(msg.get("reasoning_content"), str):
+            reasoning_content = msg["reasoning_content"]
+            has_reasoning = True
+        elif "</think>" in content:
+            before, after = content.split("</think>", 1)
+            reasoning_content = before.split("<think>")[-1].strip()
+            content = after.strip()
+            has_reasoning = True
+
+        emit_special(self._assistant, msg_idx, is_sampled=False, is_content=False)
+        include_thinking = has_reasoning and (
+            not self.config.clear_thinking or msg_idx > last_user_index
+        )
+        emit_special(self._think, msg_idx, is_sampled=False, is_content=False)
+        if include_thinking:
+            emit_text(reasoning_content, msg_idx, is_sampled=True, is_content=True)
+        emit_special(self._think_end, msg_idx, is_sampled=True, is_content=True)
+        if content.strip():
+            emit_text(content.strip(), msg_idx, is_sampled=True, is_content=True)
+
+        self._render_tool_calls(
+            msg, msg_idx, emit_special=emit_special, emit_text=emit_text
+        )
+
+    def _render_tool_calls(self, msg, msg_idx, *, emit_special, emit_text) -> None:
+        for tc in msg.get("tool_calls") or []:
+            func = tc.get("function") or tc
+            arguments = func.get("arguments", {})
+            if isinstance(arguments, str):
+                arguments = json.loads(arguments)
+            emit_special(self._tool_call_tok, msg_idx, is_sampled=True, is_content=True)
+            emit_text(func.get("name", ""), msg_idx, is_sampled=True, is_content=True)
+            for arg_name, arg_value in arguments.items():
+                emit_special(self._arg_key, msg_idx, is_sampled=True, is_content=True)
+                emit_text(arg_name, msg_idx, is_sampled=True, is_content=True)
+                emit_special(
+                    self._arg_key_end, msg_idx, is_sampled=True, is_content=True
+                )
+                emit_special(self._arg_value, msg_idx, is_sampled=True, is_content=True)
+                emit_text(
+                    arg_value
+                    if isinstance(arg_value, str)
+                    else json.dumps(arg_value, ensure_ascii=False),
+                    msg_idx,
+                    is_sampled=True,
+                    is_content=True,
+                )
+                emit_special(
+                    self._arg_value_end, msg_idx, is_sampled=True, is_content=True
+                )
+            emit_special(
+                self._tool_call_end_tok, msg_idx, is_sampled=True, is_content=True
+            )

{renderers-0.1.12.dev4 → renderers-0.1.12.dev6}/tests/parity.py

@@ -2,7 +2,8 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass, field as dataclass_field
+from dataclasses import dataclass
+from dataclasses import field as dataclass_field
 from itertools import product
 from typing import Any, Iterable, Mapping
 
@@ -10,7 +11,6 @@ from renderers.base import MODEL_RENDERER_MAP
 from renderers.configs import _config_class_for
 from tests.reference_rendering import reference_oracle_for_renderer
 
-
 TOOLS = [
     {
         "type": "function",
@@ -158,6 +158,11 @@ MODEL_CATALOG = (
         extra_suites={"tool-arg-types", "glm-tool-names"},
     ),
     _model("zai-org/GLM-5.1", bridge=True),
+    _model(
+        "zai-org/GLM-5.3",
+        bridge=True,
+        extra_suites={"tool-arg-types", "glm-tool-names"},
+    ),
     _model("zai-org/GLM-4.7-Flash"),
     _model(
         "THUDM/GLM-4.5-Air",
@@ -710,8 +715,7 @@ def kwarg_combinations(case: ModelCase) -> tuple[dict[str, Any], ...]:
     missing = set(fields) - KWARG_VALUES.keys()
     if missing:
         raise AssertionError(
-            f"{case.resolved_renderer} declares uncovered template fields: "
-            f"{sorted(missing)}"
+            f"{case.resolved_renderer} declares uncovered template fields: {sorted(missing)}"
         )
     if not fields:
         return ({},)

{renderers-0.1.12.dev4 → renderers-0.1.12.dev6}/tests/test_renderer_config.py

@@ -7,12 +7,12 @@ from typing import Literal
 
 import pytest
 from pydantic import TypeAdapter, ValidationError
-
 from renderers import (
     AutoRendererConfig,
     BaseRendererConfig,
     DefaultRendererConfig,
     GLM5RendererConfig,
+    GLM53RendererConfig,
     GptOssRendererConfig,
     Nemotron3RendererConfig,
     Qwen3RendererConfig,
@@ -53,6 +53,12 @@ def test_discriminated_union_dispatches_on_name():
     assert parsed.clear_thinking is False
 
 
+def test_glm53_defaults_match_its_template():
+    cfg = GLM53RendererConfig()
+    assert cfg.clear_thinking is False
+    assert cfg.reasoning_effort == "max"
+
+
 def test_discriminated_union_rejects_wrong_renderer_kwargs():
     """``add_vision_id`` under ``name="qwen3"`` is invalid at deserialise
     time — the discriminator narrows to ``Qwen3RendererConfig`` whose