renderers 0.1.13.dev4__tar.gz → 0.1.13.dev5__tar.gz

{renderers-0.1.13.dev4 → renderers-0.1.13.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: renderers
-Version: 0.1.13.dev4
+Version: 0.1.13.dev5
 Summary: Chat template renderers — deterministic message-to-token conversion for LLM training
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -114,7 +114,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-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).
+Hand-coded renderers ship for `qwen3`, `qwen3-vl`, `qwen3.5`, `qwen3.6`, `qwen3.8`, `gemma4`, `glm-5`, `glm-5.1`, `glm-5.3`, `glm-5.3-flash`, `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`, `glm-5.3-flash`, `kimi-k2.5` / `kimi-k2.6`, and the Inkling checkpoints are multimodal (Inkling handles both image **and** audio; `glm-5.3-flash` renders images only with `process_multimodal=False`).
 
 ## API
 

{renderers-0.1.13.dev4 → renderers-0.1.13.dev5}/README.md

@@ -94,7 +94,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-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).
+Hand-coded renderers ship for `qwen3`, `qwen3-vl`, `qwen3.5`, `qwen3.6`, `qwen3.8`, `gemma4`, `glm-5`, `glm-5.1`, `glm-5.3`, `glm-5.3-flash`, `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`, `glm-5.3-flash`, `kimi-k2.5` / `kimi-k2.6`, and the Inkling checkpoints are multimodal (Inkling handles both image **and** audio; `glm-5.3-flash` renders images only with `process_multimodal=False`).
 
 ## API
 

{renderers-0.1.13.dev4 → renderers-0.1.13.dev5}/docs/renderer-config.md

@@ -34,7 +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-5.3 / 5.3 Flash | `GLM53RendererConfig` / `GLM53FlashRendererConfig` | `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` | - |
@@ -141,7 +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-5.3 / 5.3 Flash | `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.13.dev4 → renderers-0.1.13.dev5}/renderers/__init__.py

@@ -55,6 +55,7 @@ from renderers.configs import (
     GLM5RendererConfig,
     GLM45RendererConfig,
     GLM51RendererConfig,
+    GLM53FlashRendererConfig,
     GLM53RendererConfig,
     GptOssRendererConfig,
     Hy3RendererConfig,
@@ -95,6 +96,7 @@ _LAZY_RENDERERS: dict[str, str] = {
     "DefaultRenderer": "renderers.default",
     "GLM45Renderer": "renderers.glm45",
     "GLM51Renderer": "renderers.glm5",
+    "GLM53FlashRenderer": "renderers.glm5",
     "GLM53Renderer": "renderers.glm5",
     "GLM5Renderer": "renderers.glm5",
     "GptOssRenderer": "renderers.gpt_oss",
@@ -155,6 +157,8 @@ __all__ = [
     "GLM45RendererConfig",
     "GLM51Renderer",
     "GLM51RendererConfig",
+    "GLM53FlashRenderer",
+    "GLM53FlashRendererConfig",
     "GLM53Renderer",
     "GLM53RendererConfig",
     "GLM5Renderer",

{renderers-0.1.13.dev4 → renderers-0.1.13.dev5}/renderers/_version.py

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

{renderers-0.1.13.dev4 → renderers-0.1.13.dev5}/renderers/base.py

@@ -1012,6 +1012,8 @@ MODEL_RENDERER_MAP: dict[str, str] = {
     "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",
+    "zai-org/GLM-5.3-Flash": "glm-5.3-flash",
+    "zai-org/GLM-5.3-Flash-BF16": "glm-5.3-flash",
     # GLM-4.5.
     "THUDM/GLM-4.5-Air": "glm-4.5",
     "zai-org/GLM-4.5-Air": "glm-4.5",
@@ -1353,7 +1355,12 @@ def _populate_registry():
     from renderers.deepseek_v4 import DeepSeekV4Renderer
     from renderers.default import DefaultRenderer
     from renderers.gemma4 import Gemma4Renderer
-    from renderers.glm5 import GLM5Renderer, GLM51Renderer, GLM53Renderer
+    from renderers.glm5 import (
+        GLM5Renderer,
+        GLM51Renderer,
+        GLM53FlashRenderer,
+        GLM53Renderer,
+    )
     from renderers.glm45 import GLM45Renderer
     from renderers.gpt_oss import GptOssRenderer
     from renderers.hy3 import Hy3Renderer
@@ -1393,6 +1400,7 @@ def _populate_registry():
             "glm-5": GLM5Renderer,
             "glm-5.1": GLM51Renderer,
             "glm-5.3": GLM53Renderer,
+            "glm-5.3-flash": GLM53FlashRenderer,
             "glm-4.5": GLM45Renderer,
             "minimax-m2": MiniMaxM2Renderer,
             "deepseek-v3": DeepSeekV3Renderer,

{renderers-0.1.13.dev4 → renderers-0.1.13.dev5}/renderers/client.py

@@ -336,7 +336,9 @@ async def generate(
         "token_ids": prompt_ids,
         "sampling_params": sp,
     }
-    content_parts = _content_parts(messages) if not process_multimodal else None
+    content_parts = (
+        _content_parts(messages, renderer=renderer) if not process_multimodal else None
+    )
     features = (
         _build_mm_features(renderer, mm_data)
         if process_multimodal and mm_data and not mm_data.is_empty()
@@ -454,8 +456,15 @@ _MEDIA_URL_TYPES = {
 }
 
 
-def _content_parts(messages: list[Message]) -> list[dict[str, Any]]:
+def _content_parts(
+    messages: list[Message], *, renderer: Renderer
+) -> list[dict[str, Any]]:
     """Flatten raw media in prompt order for vLLM's token generate endpoint."""
+    # Some templates reorder tool results. Use the same order for raw media,
+    # including when the caller supplies a prebuilt prompt and skips rendering.
+    order_messages = getattr(renderer, "messages_in_prompt_order", None)
+    if order_messages is not None:
+        messages = order_messages(messages)
     parts: list[dict[str, Any]] = []
     for message in messages:
         content = message.get("content")

{renderers-0.1.13.dev4 → renderers-0.1.13.dev5}/renderers/configs.py

@@ -434,6 +434,12 @@ class GLM53RendererConfig(BaseRendererConfig):
         return self
 
 
+class GLM53FlashRendererConfig(GLM53RendererConfig):
+    """GLM-5.3 Flash renderer config. GLM-5.3's template surface, plus images."""
+
+    name: Literal["glm-5.3-flash"] = "glm-5.3-flash"
+
+
 class GLM45RendererConfig(BaseRendererConfig):
     """GLM-4.5 Air renderer config."""
 
@@ -1042,6 +1048,7 @@ RendererConfig = Annotated[
         GLM5RendererConfig,
         GLM51RendererConfig,
         GLM53RendererConfig,
+        GLM53FlashRendererConfig,
         GLM45RendererConfig,
         GptOssRendererConfig,
         Hy3RendererConfig,
@@ -1091,6 +1098,7 @@ _CONFIG_BY_NAME: dict[str, type[BaseRendererConfig]] = {
     "glm-5": GLM5RendererConfig,
     "glm-5.1": GLM51RendererConfig,
     "glm-5.3": GLM53RendererConfig,
+    "glm-5.3-flash": GLM53FlashRendererConfig,
     "glm-4.5": GLM45RendererConfig,
     "gpt-oss": GptOssRendererConfig,
     "hy3": Hy3RendererConfig,
@@ -1144,6 +1152,7 @@ __all__ = [
     "DeepSeekV4RendererConfig",
     "GLM45RendererConfig",
     "GLM51RendererConfig",
+    "GLM53FlashRendererConfig",
     "GLM53RendererConfig",
     "GLM5RendererConfig",
     "Gemma4RendererConfig",

{renderers-0.1.13.dev4 → renderers-0.1.13.dev5}/renderers/glm5.py

@@ -12,10 +12,12 @@ Key differences from Qwen family:
 from __future__ import annotations
 
 import json
+from collections.abc import Mapping
 from typing import Any
 
 from renderers.base import (
     Message,
+    MultiModalData,
     ParsedResponse,
     RenderedTokens,
     Tokenizer,
@@ -30,6 +32,7 @@ from renderers.base import (
 from renderers.configs import (
     GLM5RendererConfig,
     GLM51RendererConfig,
+    GLM53FlashRendererConfig,
     GLM53RendererConfig,
 )
 from renderers.parsing import parse_glm
@@ -52,6 +55,24 @@ _TOOLS_FOOTER = (
 )
 
 
+def _is_list_of_outputs(content: Any) -> bool:
+    return (
+        isinstance(content, list)
+        and bool(content)
+        and isinstance(content[0], dict)
+        and "output" in content[0]
+    )
+
+
+def _tool_contents(content: Any) -> list[Any]:
+    if _is_list_of_outputs(content):
+        return [
+            entry.get("output") if isinstance(entry, dict) else None
+            for entry in content
+        ]
+    return [content]
+
+
 class GLM5Renderer:
     """Deterministic message → token renderer for GLM-5 models."""
 
@@ -138,6 +159,26 @@ class GLM5Renderer:
             return "".join(parts)
         return str(content)
 
+    def _emit_body(
+        self, content: Any, msg_idx: int, *, emit_special, emit_text
+    ) -> None:
+        """Emit a system, user or tool message body. Renderers for models that
+        read images in the conversation override this to place the media."""
+        emit_text(
+            self._visible_text(content), msg_idx, is_sampled=False, is_content=True
+        )
+
+    def _emit_tool_body(
+        self, content: Any, msg_idx: int, *, tools, emit_special, emit_text
+    ) -> None:
+        self._emit_body(
+            content, msg_idx, emit_special=emit_special, emit_text=emit_text
+        )
+
+    @staticmethod
+    def _prompt_tools(tools: list[ToolSpec]) -> list[ToolSpec]:
+        return tools
+
     @staticmethod
     def _last_user_index(messages: list[Message]) -> int:
         for i in range(len(messages) - 1, -1, -1):
@@ -218,7 +259,7 @@ class GLM5Renderer:
         if tools:
             emit_special(self._system, -1, is_sampled=False, is_content=False)
             tool_text = _TOOLS_HEADER
-            for tool in tools:
+            for tool in self._prompt_tools(tools):
                 tool_text += self._format_tool_spec(tool) + "\n"
             tool_text += _TOOLS_FOOTER
             emit_text(tool_text, -1, is_sampled=False, is_content=False)
@@ -237,7 +278,12 @@ class GLM5Renderer:
 
             if role == "system":
                 emit_special(self._system, i, is_sampled=False, is_content=False)
-                emit_text(content, i, is_sampled=False, is_content=True)
+                self._emit_body(
+                    msg.get("content"),
+                    i,
+                    emit_special=emit_special,
+                    emit_text=emit_text,
+                )
 
             elif role == "user":
                 emit_special(
@@ -246,7 +292,12 @@ class GLM5Renderer:
                     is_sampled=closes_assistant_turn,
                     is_content=closes_assistant_turn,
                 )
-                emit_text(content, i, is_sampled=False, is_content=True)
+                self._emit_body(
+                    msg.get("content"),
+                    i,
+                    emit_special=emit_special,
+                    emit_text=emit_text,
+                )
 
             elif role == "assistant":
                 self._render_assistant(
@@ -261,13 +312,13 @@ class GLM5Renderer:
 
             elif role == "tool":
                 if i == 0 or messages[i - 1]["role"] != "tool":
-                    for position, tool_idx in enumerate(
-                        self._ordered_tool_indices(messages, i)
+                    for position, (tool_idx, tool_content) in enumerate(
+                        self._tool_results(messages, i)
                     ):
-                        tool_message = messages[tool_idx]
                         self._render_tool(
                             tool_idx,
-                            self._visible_text(tool_message.get("content")),
+                            tool_content,
+                            tools=tools,
                             emit_special=emit_special,
                             emit_text=emit_text,
                             emit_text_segments=emit_text_segments,
@@ -316,6 +367,14 @@ class GLM5Renderer:
             block_end += 1
         return list(range(block_start, block_end + 1))
 
+    def _tool_results(
+        self, messages: list[Message], block_start: int
+    ) -> list[tuple[int, Any]]:
+        return [
+            (i, messages[i].get("content"))
+            for i in self._ordered_tool_indices(messages, block_start)
+        ]
+
     def render_ids(
         self,
         messages: list[Message],
@@ -469,15 +528,24 @@ class GLM5Renderer:
         # *actually* produced this step.
         for i, msg in enumerate(new_messages):
             role = msg.get("role")
-            content = self._visible_text(msg.get("content"))
             if role == "user":
                 # Dedup: model already emitted <|user|> as its stop token.
                 if not (i == 0 and last_prev == self._user):
                     emit_special(self._user, i)
-                emit_text(content, i, is_content=True)
+                self._emit_body(
+                    msg.get("content"),
+                    i,
+                    emit_special=emit_special,
+                    emit_text=emit_text,
+                )
             elif role == "system":
                 emit_special(self._system, i)
-                emit_text(content, i, is_content=True)
+                self._emit_body(
+                    msg.get("content"),
+                    i,
+                    emit_special=emit_special,
+                    emit_text=emit_text,
+                )
             elif role == "tool":
                 prev_is_tool = i > 0 and new_messages[i - 1].get("role") == "tool"
                 if i == 0 and last_prev == self._observation:
@@ -486,7 +554,13 @@ class GLM5Renderer:
                 elif not prev_is_tool:
                     emit_special(self._observation, i)
                 emit_special(self._tool_response_tok, i)
-                emit_text(content, i, is_content=True)
+                self._emit_tool_body(
+                    msg.get("content"),
+                    i,
+                    tools=tools,
+                    emit_special=emit_special,
+                    emit_text=emit_text,
+                )
                 emit_special(self._tool_response_end_tok, i)
             else:
                 return None
@@ -637,8 +711,9 @@ class GLM5Renderer:
     def _render_tool(
         self,
         msg_idx: int,
-        content: str,
+        content: Any,
         *,
+        tools: list[ToolSpec] | None = None,
         emit_special,
         emit_text,
         emit_text_segments,
@@ -664,7 +739,13 @@ class GLM5Renderer:
         emit_special(
             self._tool_response_tok, msg_idx, is_sampled=False, is_content=False
         )
-        emit_text(content, msg_idx, is_sampled=False, is_content=True)
+        self._emit_tool_body(
+            content,
+            msg_idx,
+            tools=tools,
+            emit_special=emit_special,
+            emit_text=emit_text,
+        )
         emit_special(
             self._tool_response_end_tok, msg_idx, is_sampled=False, is_content=False
         )
@@ -727,10 +808,45 @@ class GLM53Renderer(GLM5Renderer):
         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(
+    @staticmethod
+    def _prompt_tools(tools: list[ToolSpec]) -> list[ToolSpec]:
+        return [
+            tool
+            for tool in tools
+            if not (tool.get("function") or tool).get("defer_loading")
+        ]
+
+    def _emit_tool_body(
+        self, content: Any, msg_idx: int, *, tools, emit_special, emit_text
+    ) -> None:
+        if (
+            isinstance(content, list)
+            and content
+            and isinstance(content[0], dict)
+            and content[0].get("type") == "tool_reference"
+        ):
+            if not tools:
+                raise ValueError("Tool references require tool specifications")
+            text = "<tools>\n"
+            for reference in content:
+                for tool in tools:
+                    spec = tool.get("function") or tool
+                    if spec.get("name") == reference.get("name"):
+                        text += self._format_tool_spec(tool) + "\n"
+            emit_text(text + "</tools>", msg_idx, is_sampled=False, is_content=False)
+        else:
+            super()._emit_tool_body(
+                content,
+                msg_idx,
+                tools=tools,
+                emit_special=emit_special,
+                emit_text=emit_text,
+            )
+
+    def _tool_results(
         self, messages: list[Message], block_start: int
-    ) -> list[int]:
-        """Match the template's safe tool-result reordering rule."""
+    ) -> list[tuple[int, Any]]:
+        """Unpack and order tool results, retaining each input message's owner."""
         block_end = block_start
         while (
             block_end + 1 < len(messages)
@@ -738,31 +854,55 @@ class GLM53Renderer(GLM5Renderer):
         ):
             block_end += 1
 
+        def identifier(obj: Mapping[str, Any]) -> str:
+            return str(obj.get("tool_call_id") or obj.get("id") or "")
+
+        results: list[tuple[int, str, Any]] = []
+        for i in range(block_start, block_end + 1):
+            content = messages[i].get("content")
+            if _is_list_of_outputs(content):
+                for entry in content:
+                    entry = entry if isinstance(entry, dict) else {}
+                    results.append((i, identifier(entry), entry.get("output")))
+            else:
+                results.append((i, identifier(messages[i]), content))
+
         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))
+        if calls:
+            call_ids = [identifier(call) for call in calls]
+            result_ids = [result_id for _, result_id, _ in results]
+            if (
+                all(call_ids)
+                and all(result_ids)
+                and len(set(call_ids)) == len(call_ids)
+                and len(set(result_ids)) == len(result_ids)
+                and set(result_ids) <= set(call_ids)
+            ):
+                by_id = {result_id: (i, content) for i, result_id, content in results}
+                return [by_id[call_id] for call_id in call_ids if call_id in by_id]
+        return [(i, content) for i, _, content in results]
 
-        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)
+    def bridge_to_next_turn(
+        self,
+        previous_prompt_ids: list[int],
+        previous_completion_ids: list[int],
+        new_messages: list[Message],
+        *,
+        tools: list[ToolSpec] | None = None,
+    ) -> RenderedTokens | None:
+        tool_messages = [m for m in new_messages if m.get("role") == "tool"]
+        if len(tool_messages) > 1 or any(
+            _is_list_of_outputs(m.get("content")) for m in tool_messages
         ):
-            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]
+            # Sorting needs the original assistant's tool-call IDs. Those IDs
+            # cannot be recovered from the raw sampled completion tokens.
+            return None
+        return super().bridge_to_next_turn(
+            previous_prompt_ids, previous_completion_ids, new_messages, tools=tools
+        )
 
     def render(
         self,
@@ -854,3 +994,154 @@ class GLM53Renderer(GLM5Renderer):
             emit_special(
                 self._tool_call_end_tok, msg_idx, is_sampled=True, is_content=True
             )
+
+
+_IMAGE_TYPES = ("image", "image_url")
+_UNSUPPORTED_MEDIA_TYPES = ("video", "video_url", "audio", "audio_url", "input_audio")
+
+
+class GLM53FlashRenderer(GLM53Renderer):
+    """Deterministic message → token renderer for GLM-5.3 Flash.
+
+    GLM-5.3 Flash shares GLM-5.3's text template and adds images: the template
+    renders each image part of a system, user or tool message as
+    ``<|begin_of_image|><|image|><|end_of_image|>``.
+
+    Renders the logical prompt (``process_multimodal=False``): one ``<|image|>``
+    per image, which the inference engine expands to the image's token count
+    from the raw image. Rendering with expanded placeholders and processed
+    pixels (``process_multimodal=True``) is not implemented yet. Video and
+    audio are not supported.
+    """
+
+    _config_cls = GLM53FlashRendererConfig
+    supports_process_multimodal = True
+
+    def __init__(
+        self,
+        tokenizer: Tokenizer,
+        config: GLM53FlashRendererConfig | None = None,
+    ):
+        super().__init__(tokenizer, config)
+        self._begin_of_image = self._token_id("<|begin_of_image|>")
+        self._image = self._token_id("<|image|>")
+        self._end_of_image = self._token_id("<|end_of_image|>")
+
+    @property
+    def mm_token_type_id_map(self) -> dict[int, int]:
+        return {self._image: 1}
+
+    @staticmethod
+    def _validate_media(messages: list[Message], *, process_multimodal: bool) -> None:
+        for message in messages:
+            contents = (
+                _tool_contents(message.get("content"))
+                if message.get("role") == "tool"
+                else [message.get("content")]
+            )
+            for content in contents:
+                if not isinstance(content, list):
+                    continue
+                for item in content:
+                    GLM53FlashRenderer._validate_media_part(
+                        item,
+                        role=message.get("role"),
+                        process_multimodal=process_multimodal,
+                    )
+
+    @staticmethod
+    def _validate_media_part(
+        item: Any, *, role: str | None, process_multimodal: bool
+    ) -> None:
+        if not isinstance(item, dict):
+            return
+        kind = item.get("type")
+        if kind in _UNSUPPORTED_MEDIA_TYPES:
+            raise NotImplementedError(
+                f"GLM53FlashRenderer does not support {kind!r} content"
+            )
+        if kind in _IMAGE_TYPES:
+            if role not in ("system", "user", "tool"):
+                raise NotImplementedError(
+                    f"GLM53FlashRenderer does not support images in {role!r} messages"
+                )
+            if process_multimodal:
+                raise NotImplementedError(
+                    "GLM53FlashRenderer renders images only with "
+                    "process_multimodal=False (one placeholder per image)"
+                )
+
+    def messages_in_prompt_order(self, messages: list[Message]) -> list[Message]:
+        """Order raw-media inputs like the full render's tool-result blocks."""
+        self._validate_media(messages, process_multimodal=False)
+        ordered: list[Message] = []
+        for i, message in enumerate(messages):
+            if message.get("role") != "tool":
+                ordered.append(message)
+            elif i == 0 or messages[i - 1].get("role") != "tool":
+                for j, content in self._tool_results(messages, i):
+                    result = messages[j].copy()
+                    result["content"] = content
+                    ordered.append(result)
+        return ordered
+
+    def _emit_body(
+        self, content: Any, msg_idx: int, *, emit_special, emit_text
+    ) -> None:
+        if not isinstance(content, list):
+            super()._emit_body(
+                content, msg_idx, emit_special=emit_special, emit_text=emit_text
+            )
+            return
+        # Consecutive text parts are joined before encoding, as the template does.
+        text = ""
+        for item in content:
+            if isinstance(item, str):
+                text += item
+            elif not isinstance(item, dict):
+                continue
+            elif item.get("type") == "text":
+                text += item.get("text", "")
+            elif item.get("type") in _IMAGE_TYPES:
+                emit_text(text, msg_idx, is_sampled=False, is_content=True)
+                text = ""
+                # The placeholder stands for caller-provided image data (body
+                # content); the markers around it are template scaffolding.
+                emit_special(
+                    self._begin_of_image, msg_idx, is_sampled=False, is_content=False
+                )
+                emit_special(self._image, msg_idx, is_sampled=False, is_content=True)
+                emit_special(
+                    self._end_of_image, msg_idx, is_sampled=False, is_content=False
+                )
+        emit_text(text, msg_idx, is_sampled=False, is_content=True)
+
+    def render(
+        self,
+        messages: list[Message],
+        *,
+        tools: list[ToolSpec] | None = None,
+        add_generation_prompt: bool = False,
+        process_multimodal: bool = True,
+    ) -> RenderedTokens:
+        self._validate_media(messages, process_multimodal=process_multimodal)
+        return super().render(
+            messages, tools=tools, add_generation_prompt=add_generation_prompt
+        )
+
+    def bridge_to_next_turn(
+        self,
+        previous_prompt_ids: list[int],
+        previous_completion_ids: list[int],
+        new_messages: list[Message],
+        *,
+        tools: list[ToolSpec] | None = None,
+        previous_multi_modal_data: MultiModalData | None = None,
+        process_multimodal: bool = True,
+    ) -> RenderedTokens | None:
+        self._validate_media(new_messages, process_multimodal=process_multimodal)
+        # Logical prompts carry no processed image data, so nothing from
+        # ``previous_multi_modal_data`` needs carrying forward.
+        return super().bridge_to_next_turn(
+            previous_prompt_ids, previous_completion_ids, new_messages, tools=tools
+        )