renderers 0.1.12.dev16__tar.gz → 0.1.12.dev18__tar.gz

{renderers-0.1.12.dev16 → renderers-0.1.12.dev18}/.github/workflows/test.yml

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

{renderers-0.1.12.dev16 → renderers-0.1.12.dev18}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.5
 Name: renderers
-Version: 0.1.12.dev16
+Version: 0.1.12.dev18
 Summary: Chat template renderers — deterministic message-to-token conversion for LLM training
 License-Expression: Apache-2.0
 License-File: LICENSE
-Requires-Python: <3.15,>=3.10
+Requires-Python: <3.15,>=3.11
 Requires-Dist: jinja2
 Requires-Dist: numpy
 Requires-Dist: openai-harmony>=0.0.4
@@ -127,7 +127,8 @@ class Renderer(Protocol):
     def bridge_to_next_turn(prev_prompt_ids, prev_completion_ids, new_messages, *, tools=None) -> list[int] | None: ...
 ```
 
-- `RenderedTokens` carries `token_ids` **and** `message_indices` — one entry per token attributing each to its source message (`-1` for structural scaffolding). Lets `build_training_sample` build a per-token loss mask in one render.
+- `RenderedTokens` carries `token_ids` **and** `message_indices` — one entry per token attributing each to its owning message (`-1` for structural scaffolding). Sampled closing markers belong to their assistant, including GLM markers emitted at the next user/tool boundary; user/tool bodies keep their own ownership.
+- `build_training_sample(..., message_loss_mask=[0, 0, 0, 1])` keeps all messages as context but restricts loss to selected messages. Supply one boolean or integer `0`/`1` per message, or `None` for the normal mask. Excluding an assistant also excludes its closing token. Selection never enables targets disabled by the existing role/content settings or changes token IDs.
 - `ParsedResponse` is `(content, reasoning_content, tool_calls)`. It scans token ids for special-token boundaries (e.g. id `151657` for `<tool_call>` on Qwen3) — a literal `"<tool_call>"` in user content tokenizes to ordinary text ids and never matches.
 - Round-trip: rendering `[user, assistant(content, reasoning, tool_calls)]`, slicing the assistant completion, and feeding it through `parse_response` returns an equivalent structured message. Tested per-renderer in `tests/test_roundtrip.py`.
 

{renderers-0.1.12.dev16 → renderers-0.1.12.dev18}/README.md

@@ -107,7 +107,8 @@ class Renderer(Protocol):
     def bridge_to_next_turn(prev_prompt_ids, prev_completion_ids, new_messages, *, tools=None) -> list[int] | None: ...
 ```
 
-- `RenderedTokens` carries `token_ids` **and** `message_indices` — one entry per token attributing each to its source message (`-1` for structural scaffolding). Lets `build_training_sample` build a per-token loss mask in one render.
+- `RenderedTokens` carries `token_ids` **and** `message_indices` — one entry per token attributing each to its owning message (`-1` for structural scaffolding). Sampled closing markers belong to their assistant, including GLM markers emitted at the next user/tool boundary; user/tool bodies keep their own ownership.
+- `build_training_sample(..., message_loss_mask=[0, 0, 0, 1])` keeps all messages as context but restricts loss to selected messages. Supply one boolean or integer `0`/`1` per message, or `None` for the normal mask. Excluding an assistant also excludes its closing token. Selection never enables targets disabled by the existing role/content settings or changes token IDs.
 - `ParsedResponse` is `(content, reasoning_content, tool_calls)`. It scans token ids for special-token boundaries (e.g. id `151657` for `<tool_call>` on Qwen3) — a literal `"<tool_call>"` in user content tokenizes to ordinary text ids and never matches.
 - Round-trip: rendering `[user, assistant(content, reasoning, tool_calls)]`, slicing the assistant completion, and feeding it through `parse_response` returns an equivalent structured message. Tested per-renderer in `tests/test_roundtrip.py`.
 

{renderers-0.1.12.dev16 → renderers-0.1.12.dev18}/examples/sglang/multiturn_generate_sglang.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env -S uv run --script
 # /// script
-# requires-python = ">=3.10,<3.14"
+# requires-python = ">=3.11,<3.14"
 # dependencies = [
 #   "renderers>=0.1.6",
 #   "sglang==0.5.10.post1",

{renderers-0.1.12.dev16 → renderers-0.1.12.dev18}/examples/sglang/online_multiturn_sglang.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env -S uv run --script
 # /// script
-# requires-python = ">=3.10,<3.14"
+# requires-python = ">=3.11,<3.14"
 # dependencies = [
 #   "renderers>=0.1.6",
 #   "transformers>=5.3.0",

{renderers-0.1.12.dev16 → renderers-0.1.12.dev18}/examples/transformers/multiturn_generate_transformers.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env -S uv run --script
 # /// script
-# requires-python = ">=3.10,<3.14"
+# requires-python = ">=3.11,<3.14"
 # dependencies = [
 #   "renderers>=0.1.6",
 #   "transformers>=4.50.0",

{renderers-0.1.12.dev16 → renderers-0.1.12.dev18}/examples/vllm/multiturn_generate_vllm.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env -S uv run --script
 # /// script
-# requires-python = ">=3.10,<3.14"
+# requires-python = ">=3.11,<3.14"
 # dependencies = [
 #   "renderers>=0.1.6",
 #   "vllm>=0.20",

{renderers-0.1.12.dev16 → renderers-0.1.12.dev18}/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.15"
+requires-python = ">=3.11,<3.15"
 dependencies = [
     "numpy",
     "openai>=1.108.1",

{renderers-0.1.12.dev16 → renderers-0.1.12.dev18}/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.dev16'
-__version_tuple__ = version_tuple = (0, 1, 12, 'dev16')
+__version__ = version = '0.1.12.dev18'
+__version_tuple__ = version_tuple = (0, 1, 12, 'dev18')
 
 __commit_id__ = commit_id = None

{renderers-0.1.12.dev16 → renderers-0.1.12.dev18}/renderers/base.py

@@ -1,15 +1,14 @@
-from __future__ import annotations
-
-import enum
 import logging
 from collections.abc import Mapping
 from dataclasses import dataclass, field
+from enum import StrEnum
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
     Literal,
     Protocol,
+    Required,
     TypedDict,
     cast,
     runtime_checkable,
@@ -110,8 +109,8 @@ class Message(TypedDict, total=False):
     Optional keys mirror the OpenAI chat format for tool calling.
     """
 
-    role: str
-    content: Content
+    role: Required[str]
+    content: Required[Content]
     tool_calls: list[ToolCall]
     tool_call_id: str
     name: str
@@ -224,8 +223,11 @@ class MultiModalData:
 class RenderedTokens:
     """Result of rendering messages to tokens.
 
-    Each token carries an index into the original message list so callers can
-    build per-token loss masks without re-rendering. Tokens from structural
+    Each token carries its owning message's index into the original message
+    list so callers can build per-token loss masks without re-rendering.
+    Sampled closing tokens belong to the assistant that generated them, even
+    when emitted while rendering the next message's role marker. User/tool
+    bodies retain their own message indices. Tokens from structural
     scaffolding the renderer adds outside any single message (e.g. the
     trailing generation prompt) carry index ``-1``.
 
@@ -383,7 +385,10 @@ class RenderedTokens:
         is not represented.
 
         Hand-coded renderers emit each message's tokens contiguously,
-        so the span is well-defined. The implementation tolerates
+        so the span is well-defined. Spans follow input-message indices,
+        not necessarily token order: templates can reorder tool results.
+        Empty messages whose role marker closes the preceding assistant
+        may have no tokens of their own. The implementation tolerates
         non-contiguous attribution by returning the outer span
         ``(first_k, last_k + 1)``; if you suspect interleaving, slice
         ``message_indices`` yourself to verify.
@@ -556,7 +561,7 @@ class RenderedTokens:
         return mask
 
 
-class ToolCallParseStatus(str, enum.Enum):
+class ToolCallParseStatus(StrEnum):
     """Per-attempt outcome of parsing a single ``<tool_call>`` block.
 
     The renderer parser's job is JSON-syntax → ``dict`` (the parser-level
@@ -1304,15 +1309,19 @@ def load_tokenizer(model_name_or_path: str):
     the requested Meta ID so auto-resolution still selects ``Llama3Renderer``.
     Requires the ``renderers[transformers]`` extra.
     """
-    _require_transformers("Loading a tokenizer")
-    load_name_or_path = _tokenizer_source_for(model_name_or_path)
-    kwargs = _tokenizer_load_kwargs(load_name_or_path)
-    tok = _load_tokenizer_via_auto(load_name_or_path, **kwargs)
-    return _preserve_requested_tokenizer_name(
-        tok,
-        requested_name_or_path=model_name_or_path,
-        loaded_name_or_path=load_name_or_path,
-    )
+    try:
+        _require_transformers("Loading a tokenizer")
+        load_name_or_path = _tokenizer_source_for(model_name_or_path)
+        kwargs = _tokenizer_load_kwargs(load_name_or_path)
+        tok = _load_tokenizer_via_auto(load_name_or_path, **kwargs)
+        return _preserve_requested_tokenizer_name(
+            tok,
+            requested_name_or_path=model_name_or_path,
+            loaded_name_or_path=load_name_or_path,
+        )
+    except Exception as exc:
+        exc.add_note(f"While loading tokenizer {model_name_or_path!r}.")
+        raise
 
 
 def _populate_registry():
@@ -1387,7 +1396,7 @@ def _populate_registry():
 
 def create_renderer(
     tokenizer,
-    config: RendererConfig | None = None,
+    config: "RendererConfig | None" = None,
     *,
     chat_template_kwargs: Mapping[str, Any] | None = None,
 ) -> Renderer:
@@ -1419,26 +1428,34 @@ def create_renderer(
     """
     _populate_registry()
 
-    config = _resolve_renderer_config(
-        tokenizer,
-        config,
-        chat_template_kwargs=chat_template_kwargs,
-    )
-    from renderers.configs import CustomRendererConfig
-    from renderers.custom import custom_renderer_config, load_custom_renderer
-
-    if isinstance(config, CustomRendererConfig):
-        renderer_cls = load_custom_renderer(config.import_path)
-        return renderer_cls(tokenizer, custom_renderer_config(config))
-    cls = RENDERER_REGISTRY.get(config.name)
-    if cls is None:
-        raise ValueError(
-            f"Unknown renderer {config.name!r}. Available: {', '.join(sorted(RENDERER_REGISTRY))}"
+    try:
+        config = _resolve_renderer_config(
+            tokenizer,
+            config,
+            chat_template_kwargs=chat_template_kwargs,
+        )
+        from renderers.configs import CustomRendererConfig
+        from renderers.custom import custom_renderer_config, load_custom_renderer
+
+        if isinstance(config, CustomRendererConfig):
+            renderer_cls = load_custom_renderer(config.import_path)
+            return renderer_cls(tokenizer, custom_renderer_config(config))
+        cls = RENDERER_REGISTRY.get(config.name)
+        if cls is None:
+            raise ValueError(
+                f"Unknown renderer {config.name!r}. Available: {', '.join(sorted(RENDERER_REGISTRY))}"
+            )
+        return cls(tokenizer, config)
+    except Exception as exc:
+        model_name = getattr(tokenizer, "name_or_path", "<unnamed tokenizer>")
+        renderer_name = config.name if config is not None else "auto"
+        exc.add_note(
+            f"While creating renderer {renderer_name!r} for tokenizer {model_name!r}."
         )
-    return cls(tokenizer, config)
+        raise
 
 
-def template_field_names(config: RendererConfig) -> frozenset[str]:
+def template_field_names(config: "RendererConfig") -> frozenset[str]:
     """Chat-template kwargs that ``config``'s renderer accepts, custom renderers included."""
     from renderers.configs import CustomRendererConfig
     from renderers.custom import load_custom_renderer
@@ -1451,9 +1468,9 @@ def template_field_names(config: RendererConfig) -> frozenset[str]:
 
 
 def merge_chat_template_kwargs(
-    config: RendererConfig,
+    config: "RendererConfig",
     chat_template_kwargs: Mapping[str, Any] | None,
-) -> RendererConfig:
+) -> "RendererConfig":
     """Return ``config`` with the template kwargs applied, validated against its allowlist."""
     if not chat_template_kwargs:
         return config
@@ -1498,10 +1515,10 @@ def merge_chat_template_kwargs(
 
 def _resolve_renderer_config(
     tokenizer,
-    config: RendererConfig | None,
+    config: "RendererConfig | None",
     *,
     chat_template_kwargs: Mapping[str, Any] | None = None,
-) -> RendererConfig:
+) -> "RendererConfig":
     """Resolve auto/default config and merge chat-template kwargs."""
     from renderers.configs import AutoRendererConfig
 
@@ -1520,10 +1537,10 @@ def _resolve_renderer_config(
 
 def _resolve_auto_config(
     tokenizer,
-    auto: AutoRendererConfig,
+    auto: "AutoRendererConfig",
     *,
     chat_template_kwargs: Mapping[str, Any] | None = None,
-) -> RendererConfig:
+) -> "RendererConfig":
     """Map ``AutoRendererConfig`` → concrete typed config via the
     tokenizer's ``name_or_path``.
 
@@ -1640,6 +1657,7 @@ def build_training_sample(
     tools: list[ToolSpec] | None = None,
     content_sft_roles: "set[str] | frozenset[str] | None" = None,
     ensure_final_stop: bool = False,
+    message_loss_mask: list[bool | int] | None = None,
 ) -> RenderedTrainingSample:
     """Build a :class:`RenderedTrainingSample` for supervised training.
 
@@ -1656,11 +1674,8 @@ def build_training_sample(
     it's attributed to. This is the recommended default for renderer
     callers — the renderer owns the per-token "is this model output"
     signal, so role-level filtering becomes a downstream constraint
-    rather than a precondition. (Some role markers — e.g. GLM
-    ``<|user|>`` / ``<|observation|>`` after a tool-calling assistant
-    turn — *are* sampled by the model at inference and live inside the
-    next message's span; ``sampled_mask`` captures that, but a
-    naive role filter would mask them out.)
+    rather than a precondition. Sampled closing markers, including GLM's
+    ``<|user|>`` / ``<|observation|>``, are attributed to their assistant.
 
     When ``role_to_mask`` is provided, ``loss_mask`` is the AND of the
     role-based attribution and the sampled signal: only tokens the
@@ -1706,7 +1721,27 @@ def build_training_sample(
     fires, the output intentionally diverges from ``apply_chat_template``.
     Ignored for renderers without ``sampled_mask`` (``DefaultRenderer``) —
     the close of an opaque template can't be located reliably.
+
+    ``message_loss_mask`` optionally selects messages for supervision with
+    one boolean or integer 0/1 per message. It only restricts the existing
+    mask: selecting a message never enables targets disabled by the role,
+    sampled, or content settings. Unselected messages remain context,
+    including prefilled assistant turns at arbitrary positions. Sampled
+    closing tokens follow their owning assistant, even when a template
+    emits them at the next message boundary. A synthesized final stop
+    follows the final message's selection. Token ids are unaffected.
+    ``None`` preserves the existing mask.
     """
+    if message_loss_mask is not None:
+        if len(message_loss_mask) != len(messages):
+            raise ValueError("message_loss_mask must have one entry per message")
+        if any(
+            not isinstance(value, (bool, int)) or value not in (0, 1)
+            for value in message_loss_mask
+        ):
+            raise ValueError(
+                "message_loss_mask entries must be booleans or integers 0/1"
+            )
     rendered = renderer.render(messages, tools=tools)
     has_sampled_info = len(rendered.sampled_mask) == len(rendered.token_ids)
     has_content_info = len(rendered.is_content) == len(rendered.token_ids)
@@ -1765,6 +1800,19 @@ def build_training_sample(
             # stop is a training target, like any sampled token.
             loss_mask.append(True)
 
+    if message_loss_mask is not None:
+        for k in range(len(loss_mask)):
+            # Any synthesized stop after the rendered sequence belongs to
+            # the final assistant, just like an in-message closing token.
+            msg_idx = (
+                rendered.message_indices[k]
+                if k < len(rendered.message_indices)
+                else len(messages) - 1
+            )
+            loss_mask[k] = (
+                loss_mask[k] and msg_idx >= 0 and bool(message_loss_mask[msg_idx])
+            )
+
     # Surface the multimodal payload for VLM renderers. ``None`` for text
     # renderers and for text-only samples (empty media) so downstream
     # ``multi_modal_data is not None`` is a reliable "has media" check.
@@ -2080,8 +2128,8 @@ def introduces_user_query(
 
 def resolve_thinking_retention(
     config: Any,
-    implied: ResolvedThinkingRetention,
-) -> ResolvedThinkingRetention:
+    implied: "ResolvedThinkingRetention",
+) -> "ResolvedThinkingRetention":
     """Resolve the effective bridge policy for a renderer instance.
 
     ``config.thinking_retention is None`` means "derive from template knobs";
@@ -2095,7 +2143,7 @@ def resolve_thinking_retention(
 
 
 def should_rerender_for_thinking_retention(
-    thinking_retention: ResolvedThinkingRetention,
+    thinking_retention: "ResolvedThinkingRetention",
     new_messages: list[Message],
     *,
     is_user_query: Callable[[Message], bool] = _is_user_message,

{renderers-0.1.12.dev16 → renderers-0.1.12.dev18}/renderers/configs.py

@@ -21,7 +21,7 @@ keys its tokenizer's template will honour, so it can't enumerate them.
 
 from __future__ import annotations
 
-from typing import Annotated, ClassVar, Literal, Union
+from typing import Annotated, ClassVar, Literal, Self, Union
 
 from pydantic import ConfigDict, Field, model_validator
 from pydantic_config import BaseConfig
@@ -159,7 +159,7 @@ class DefaultRendererConfig(BaseRendererConfig):
     _allow_opaque_template_kwargs = True
 
     @model_validator(mode="after")
-    def _reject_legacy_preserve_flags(self):
+    def _reject_legacy_preserve_flags(self) -> Self:
         # ``extra="allow"`` would otherwise swallow the removed ``preserve_*``
         # bools into ``model_extra`` and forward them to apply_chat_template,
         # silently dropping the user's intent (DefaultRenderer can't
@@ -261,7 +261,7 @@ class Qwen36RendererConfig(BaseRendererConfig):
     _internal_fields = frozenset({"image_cache_max"})
 
     @model_validator(mode="after")
-    def _check_thinking_retention(self):
+    def _check_thinking_retention(self) -> Self:
         _reject_thinking_retention_conflict(
             self,
             "preserve_thinking",
@@ -307,7 +307,7 @@ class Qwen38RendererConfig(BaseRendererConfig):
     _internal_fields = frozenset({"image_cache_max"})
 
     @model_validator(mode="after")
-    def _check_thinking_retention(self):
+    def _check_thinking_retention(self) -> Self:
         _reject_thinking_retention_conflict(
             self,
             "preserve_thinking",
@@ -350,7 +350,7 @@ class Gemma4RendererConfig(BaseRendererConfig):
     _internal_fields = frozenset({"image_cache_max"})
 
     @model_validator(mode="after")
-    def _check_thinking_retention(self):
+    def _check_thinking_retention(self) -> Self:
         _reject_thinking_retention_conflict(
             self,
             "preserve_thinking",
@@ -377,7 +377,7 @@ class GLM5RendererConfig(BaseRendererConfig):
     to ``"all"``."""
 
     @model_validator(mode="after")
-    def _check_thinking_retention(self):
+    def _check_thinking_retention(self) -> Self:
         _reject_thinking_retention_conflict(
             self,
             "clear_thinking",
@@ -401,7 +401,7 @@ class GLM51RendererConfig(BaseRendererConfig):
     """See :class:`GLM5RendererConfig.clear_thinking`."""
 
     @model_validator(mode="after")
-    def _check_thinking_retention(self):
+    def _check_thinking_retention(self) -> Self:
         _reject_thinking_retention_conflict(
             self,
             "clear_thinking",
@@ -424,7 +424,7 @@ class GLM53RendererConfig(BaseRendererConfig):
     """Reasoning-effort system preamble emitted by the canonical template."""
 
     @model_validator(mode="after")
-    def _check_thinking_retention(self):
+    def _check_thinking_retention(self) -> Self:
         _reject_thinking_retention_conflict(
             self,
             "clear_thinking",
@@ -506,7 +506,7 @@ class Hy3RendererConfig(BaseRendererConfig):
     and suppresses the generation prompt (``add_generation_prompt=False``)."""
 
     @model_validator(mode="after")
-    def _check_thinking_retention(self):
+    def _check_thinking_retention(self) -> Self:
         if self.preserved_thinking is not None and self.thinking_retention is not None:
             implied = "all" if self.preserved_thinking else "tool_cycle"
             if self.thinking_retention != implied:
@@ -566,7 +566,7 @@ class InklingRendererConfig(BaseRendererConfig):
     _internal_fields = frozenset({"image_cache_max", "audio_cache_max"})
 
     @model_validator(mode="after")
-    def _check_reasoning_effort(self):
+    def _check_reasoning_effort(self) -> Self:
         eff = self.reasoning_effort
         if isinstance(eff, str):
             if eff.strip() not in INKLING_EFFORT_MAP:
@@ -631,7 +631,7 @@ class GptOssRendererConfig(BaseRendererConfig):
     )
 
     @model_validator(mode="after")
-    def _check_thinking_retention(self):
+    def _check_thinking_retention(self) -> Self:
         _reject_thinking_retention_conflict(
             self,
             "auto_drop_analysis",
@@ -836,7 +836,7 @@ class Nemotron3RendererConfig(BaseRendererConfig):
     policy to ``"all"``."""
 
     @model_validator(mode="after")
-    def _check_thinking_retention(self):
+    def _check_thinking_retention(self) -> Self:
         _reject_thinking_retention_conflict(
             self,
             "truncate_history_thinking",
@@ -877,7 +877,7 @@ class Nemotron3UltraRendererConfig(BaseRendererConfig):
     """See :class:`Nemotron3RendererConfig.truncate_history_thinking`."""
 
     @model_validator(mode="after")
-    def _check_thinking_retention(self):
+    def _check_thinking_retention(self) -> Self:
         _reject_thinking_retention_conflict(
             self,
             "truncate_history_thinking",
@@ -913,7 +913,7 @@ class Nemotron35RendererConfig(BaseRendererConfig):
     """See :class:`Nemotron3RendererConfig.truncate_history_thinking`."""
 
     @model_validator(mode="after")
-    def _check_thinking_retention(self):
+    def _check_thinking_retention(self) -> Self:
         _reject_thinking_retention_conflict(
             self,
             "truncate_history_thinking",
@@ -984,7 +984,7 @@ class DeepSeekV4RendererConfig(BaseRendererConfig):
     """
 
     @model_validator(mode="after")
-    def _check_thinking_retention(self):
+    def _check_thinking_retention(self) -> Self:
         _reject_thinking_retention_conflict(
             self,
             "drop_thinking",
@@ -1019,7 +1019,7 @@ class CustomRendererConfig(BaseRendererConfig):
     _internal_fields = frozenset({"import_path"})
 
     @model_validator(mode="after")
-    def _validate_renderer_fields(self):
+    def _validate_renderer_fields(self) -> Self:
         # Fail at config load, not at the first render: the import path must
         # resolve and the renderer's config must accept the other fields.
         from renderers.custom import custom_renderer_config

{renderers-0.1.12.dev16 → renderers-0.1.12.dev18}/renderers/glm45.py

@@ -192,20 +192,8 @@ class GLM45Renderer:
             role = msg["role"]
             content = self._visible_text(msg.get("content"))
 
-            # When the previous message is an assistant, this message's
-            # role-opening token (``<|user|>`` / ``<|observation|>``) is
-            # the inference-time stop signal that closes the assistant's
-            # turn (see ``get_stop_token_ids``). Mark it
-            # ``is_sampled=True`` so the loss-mask pipeline trains the
-            # model to emit it after ``</tool_call>`` (instead of
-            # continuing with another ``<tool_call>`` block). The token
-            # stays attributed to this message (msg_idx=i) and remains
-            # ``is_content=False`` — it's a role-marker / scaffold, not
-            # body bytes, so ``content_mask_for_roles({"tool"})`` and
-            # ``content_token_spans_by_role()`` correctly exclude it
-            # from "tool body" views. Byte stream is unchanged.
-            # ``system`` only appears at the start of a GLM conversation,
-            # so its opener is never the closer of an assistant turn.
+            # A user/tool role marker that closes generation belongs to
+            # the preceding assistant's sampled output, not the next body.
             closes_assistant_turn = i > 0 and messages[i - 1]["role"] == "assistant"
 
             if role == "system":
@@ -219,9 +207,9 @@ class GLM45Renderer:
             elif role == "user":
                 emit_special(
                     self._user,
-                    i,
+                    i - 1 if closes_assistant_turn else i,
                     is_sampled=closes_assistant_turn,
-                    is_content=False,
+                    is_content=closes_assistant_turn,
                 )
                 # ``\n`` is scaffold; ``content`` is body; the optional
                 # ``/nothink`` suffix is scaffold the renderer injects
@@ -508,15 +496,9 @@ class GLM45Renderer:
         # (think block + content + tool calls) is the model-sampled
         # portion.
         #
-        # GLM-4.5 does NOT emit an explicit per-turn close token inside
-        # the assistant message; the next message's role marker
-        # (``<|user|>`` / ``<|observation|>`` / ``<|endoftext|>``) acts
-        # as the stop signal at inference, and those tokens are
-        # attributed to the *next* message (or are absent on the final
-        # turn). So no sampled stop-signal token lives inside this
-        # assistant span — content / think / tool_calls carry the
-        # is_sampled=True signal.
-        #
+        # The next user/tool role marker closes this assistant turn and
+        # is attributed here when that later message is rendered.
+
         # Invariant on assistant tokens: ``is_content == sampled_mask``.
         # Every scaffold token here gets ``is_sampled=False/is_content=False``;
         # every model-sampled emit gets both True.
@@ -598,23 +580,17 @@ class GLM45Renderer:
         emit_text,
         emit_text_segments,
     ) -> None:
-        # Tool body bytes get ``is_content=True``; the wraps are
-        # scaffold. The ``<|observation|>`` role tag is scaffold too
-        # (``is_content=False`` so ``content_mask_for_roles({"tool"})``
-        # excludes it). When the previous message is an assistant it
-        # doubles as the inference stop signal for that assistant's
-        # turn — mark it ``is_sampled=True`` so SFT trains the model to
-        # emit it after ``</tool_call>``. The token stays attributed to
-        # this tool message; byte stream is unchanged.
+        # Tool bodies keep their own attribution; a sampled observation
+        # marker belongs to the assistant that generated it.
         prev_role = messages[msg_idx - 1]["role"] if msg_idx > 0 else None
         closes_assistant_turn = prev_role == "assistant"
 
         if prev_role != "tool":
             emit_special(
                 self._observation,
-                msg_idx,
+                msg_idx - 1 if closes_assistant_turn else msg_idx,
                 is_sampled=closes_assistant_turn,
-                is_content=False,
+                is_content=closes_assistant_turn,
             )
 
         emit_text_segments(