renderers 0.1.9.dev9__tar.gz → 0.1.10.dev1__tar.gz

{renderers-0.1.9.dev9 → renderers-0.1.10.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: renderers
-Version: 0.1.9.dev9
+Version: 0.1.10.dev1
 Summary: Chat template renderers — deterministic message-to-token conversion for LLM training
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -56,7 +56,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`, `deepseek-r1`, `kimi-k2`, `kimi-k2.5` / `kimi-k2.6`, `nemotron-3`, `nemotron-3-ultra`, `llama-3`, `gpt-oss`, `hy3`, and `prime-qwen3`. 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`, `deepseek-r1`, `kimi-k2`, `kimi-k2.5` / `kimi-k2.6`, `laguna-xs.2`, `laguna-xs-2.1`, `laguna-m.1`, `nemotron-3`, `nemotron-3-ultra`, `llama-3`, `gpt-oss`, `hy3`, and `prime-qwen3`. Anything else falls back to `DefaultRenderer`, a generic `apply_chat_template` wrapper.
 
 ## API
 

{renderers-0.1.9.dev9 → renderers-0.1.10.dev1}/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`, `deepseek-r1`, `kimi-k2`, `kimi-k2.5` / `kimi-k2.6`, `nemotron-3`, `nemotron-3-ultra`, `llama-3`, `gpt-oss`, `hy3`, and `prime-qwen3`. 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`, `deepseek-r1`, `kimi-k2`, `kimi-k2.5` / `kimi-k2.6`, `laguna-xs.2`, `laguna-xs-2.1`, `laguna-m.1`, `nemotron-3`, `nemotron-3-ultra`, `llama-3`, `gpt-oss`, `hy3`, and `prime-qwen3`. Anything else falls back to `DefaultRenderer`, a generic `apply_chat_template` wrapper.
 
 ## API
 

{renderers-0.1.9.dev9 → renderers-0.1.10.dev1}/docs/renderer-config.md

@@ -37,6 +37,7 @@ chat-template kwargs. Those fields are covered by parity tests against
 | Kimi K2 | `KimiK2RendererConfig` | - | `enable_thinking` |
 | Kimi K2.5 / 2.6 | `KimiK25RendererConfig` | `thinking` | `image_cache_max` |
 | Laguna XS.2 | `LagunaXS2RendererConfig` | `enable_thinking`, `render_assistant_messages_raw` | - |
+| Laguna M.1 | `LagunaM1RendererConfig` | `enable_thinking`, `render_assistant_messages_raw` | - |
 | Laguna XS-2.1 | `LagunaXS21RendererConfig` | `enable_thinking` | - |
 | Llama 3 | `Llama3RendererConfig` | `date_string`, `tools_in_user_message` | - |
 | MiniMax M2 | `MiniMaxM2RendererConfig` | `model_identity` | - |
@@ -136,7 +137,7 @@ the knobs its template actually exposes:
 | Nemotron-3 | `truncate_history_thinking=False -> all`; else `enable_thinking=False -> all`; else `tool_cycle` |
 | DeepSeek R1 | `template` |
 | MiniMax M2 | `tool_cycle` |
-| DeepSeek V3, Qwen3-VL, Kimi K2, Laguna XS.2 / XS-2.1, Llama 3 | `all` |
+| DeepSeek V3, Qwen3-VL, Kimi K2, Laguna XS.2 / M.1 / XS-2.1, Llama 3 | `all` |
 | PrimeIntellect Qwen3 | `all` |
 
 Config construction raises when an explicit template knob directly contradicts

{renderers-0.1.9.dev9 → renderers-0.1.10.dev1}/renderers/__init__.py

@@ -54,6 +54,7 @@ from renderers.configs import (
     Hy3RendererConfig,
     KimiK25RendererConfig,
     KimiK2RendererConfig,
+    LagunaM1RendererConfig,
     LagunaXS2RendererConfig,
     LagunaXS21RendererConfig,
     Llama3RendererConfig,
@@ -90,6 +91,7 @@ _LAZY_RENDERERS: dict[str, str] = {
     "Hy3Renderer": "renderers.hy3",
     "KimiK25Renderer": "renderers.kimi_k25",
     "KimiK2Renderer": "renderers.kimi_k2",
+    "LagunaM1Renderer": "renderers.laguna_xs2",
     "LagunaXS21Renderer": "renderers.laguna_xs2",
     "LagunaXS2Renderer": "renderers.laguna_xs2",
     "Llama3Renderer": "renderers.llama_3",
@@ -145,6 +147,8 @@ __all__ = [
     "KimiK25RendererConfig",
     "KimiK2Renderer",
     "KimiK2RendererConfig",
+    "LagunaM1Renderer",
+    "LagunaM1RendererConfig",
     "LagunaXS2Renderer",
     "LagunaXS2RendererConfig",
     "LagunaXS21Renderer",

{renderers-0.1.9.dev9 → renderers-0.1.10.dev1}/renderers/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.9.dev9'
-__version_tuple__ = version_tuple = (0, 1, 9, 'dev9')
+__version__ = version = '0.1.10.dev1'
+__version_tuple__ = version_tuple = (0, 1, 10, 'dev1')
 
 __commit_id__ = commit_id = None

{renderers-0.1.9.dev9 → renderers-0.1.10.dev1}/renderers/base.py

@@ -117,6 +117,7 @@ class Message(TypedDict, total=False):
     tool_calls: list[ToolCall]
     tool_call_id: str
     name: str
+    reasoning: str
     reasoning_content: str
 
 
@@ -1072,9 +1073,10 @@ MODEL_RENDERER_MAP: dict[str, str] = {
     # construction to pin a different date.
     "meta-llama/Llama-3.2-1B-Instruct": "llama-3",
     "meta-llama/Llama-3.2-3B-Instruct": "llama-3",
-    # Poolside Laguna. The two checkpoints ship different chat templates,
-    # each mirrored by its own renderer class.
+    # Poolside Laguna. These checkpoints ship distinct chat templates,
+    # each mirrored by its own renderer class/config discriminator.
     "poolside/Laguna-XS.2": "laguna-xs.2",
+    "poolside/Laguna-M.1": "laguna-m.1",
     "poolside/Laguna-XS-2.1": "laguna-xs-2.1",
     # GPT-OSS.
     "openai/gpt-oss-20b": "gpt-oss",
@@ -1323,7 +1325,11 @@ def _populate_registry():
     from renderers.hy3 import Hy3Renderer
     from renderers.kimi_k2 import KimiK2Renderer
     from renderers.kimi_k25 import KimiK25Renderer
-    from renderers.laguna_xs2 import LagunaXS2Renderer, LagunaXS21Renderer
+    from renderers.laguna_xs2 import (
+        LagunaM1Renderer,
+        LagunaXS2Renderer,
+        LagunaXS21Renderer,
+    )
     from renderers.llama_3 import Llama3Renderer
     from renderers.minimax_m2 import MiniMaxM2Renderer
     from renderers.nemotron3 import Nemotron3Renderer, Nemotron3UltraRenderer
@@ -1351,6 +1357,7 @@ def _populate_registry():
             "kimi-k2": KimiK2Renderer,
             "kimi-k2.5": KimiK25Renderer,
             "laguna-xs.2": LagunaXS2Renderer,
+            "laguna-m.1": LagunaM1Renderer,
             "laguna-xs-2.1": LagunaXS21Renderer,
             "llama-3": Llama3Renderer,
             "nemotron-3": Nemotron3Renderer,

{renderers-0.1.9.dev9 → renderers-0.1.10.dev1}/renderers/client.py

@@ -1,4 +1,4 @@
-"""Renderer-based generate client for vLLM 0.20's /inference/v1/generate.
+"""Renderer-based generate client for vLLM's /inference/v1/generate.
 
     messages → Renderer.render_ids() → token IDs → POST /inference/v1/generate
     → completion tokens → Renderer.parse_response() → structured message
@@ -58,8 +58,7 @@ class OverlongPromptError(Exception):
         self.prompt_len = prompt_len
         self.max_prompt_len = max_prompt_len
         super().__init__(
-            f"Prompt length ({prompt_len}) exceeds maximum "
-            f"context length ({max_prompt_len})."
+            f"Prompt length ({prompt_len}) exceeds maximum context length ({max_prompt_len})."
         )
 
 
@@ -187,32 +186,26 @@ def _parse_completion_logprobs(
         expected_token = f"token_id:{completion_ids[index]}"
         if entry.get("token") != expected_token:
             raise MalformedGenerateResponseError(
-                "Engine response "
-                f"choice.logprobs.content[{index}].token must be {expected_token!r}."
+                f"Engine response choice.logprobs.content[{index}].token must be {expected_token!r}."
             )
         raw_logprob = entry.get("logprob")
         if isinstance(raw_logprob, bool) or not isinstance(raw_logprob, (int, float)):
             raise MalformedGenerateResponseError(
-                "Engine response "
-                f"choice.logprobs.content[{index}].logprob must be a number."
+                f"Engine response choice.logprobs.content[{index}].logprob must be a number."
             )
         try:
             logprob = float(raw_logprob)
         except OverflowError as exc:
             raise MalformedGenerateResponseError(
-                "Engine response "
-                f"choice.logprobs.content[{index}].logprob must be finite."
+                f"Engine response choice.logprobs.content[{index}].logprob must be finite."
             ) from exc
         if not math.isfinite(logprob):
             raise MalformedGenerateResponseError(
-                "Engine response "
-                f"choice.logprobs.content[{index}].logprob must be finite."
+                f"Engine response choice.logprobs.content[{index}].logprob must be finite."
             )
         if logprob == VLLM_LOGPROB_SENTINEL:
             raise MalformedGenerateResponseError(
-                "Engine response "
-                f"choice.logprobs.content[{index}].logprob does not contain "
-                "sampling evidence."
+                f"Engine response choice.logprobs.content[{index}].logprob does not contain sampling evidence."
             )
         completion_logprobs.append(logprob)
     return completion_logprobs
@@ -424,9 +417,9 @@ def _build_mm_features(
     model-family specific. For now we dispatch on the renderer class;
     extend the dispatch table as more multimodal renderers land.
 
-    NOTE — future engine pluggability: this encoder is vLLM 0.20-specific
+    NOTE — future engine pluggability: this encoder is vLLM-specific
     (uses ``vllm.multimodal.inputs.MultiModalKwargsItems``,
-    ``vllm.entrypoints.serve.disagg.mm_serde.encode_mm_kwargs_item``, and
+    ``vllm.entrypoints.scale_out.token_in_token_out.mm_serde.encode_mm_kwargs_item``, and
     ``_create_qwen2vl_field_factory``). When a second inference engine
     arrives (SGLang, MAX, ...) the renderer client should be parameterized
     on engine: either (a) move the encoder onto the renderer as
@@ -473,7 +466,9 @@ def _build_qwen_vl_features(
     try:
         import torch
         from transformers.feature_extraction_utils import BatchFeature
-        from vllm.entrypoints.serve.disagg.mm_serde import encode_mm_kwargs_item
+        from vllm.entrypoints.scale_out.token_in_token_out.mm_serde import (
+            encode_mm_kwargs_item,
+        )
         from vllm.model_executor.models.qwen2_vl import _create_qwen2vl_field_factory
         from vllm.multimodal.inputs import MultiModalKwargsItems
     except ImportError as exc:

{renderers-0.1.9.dev9 → renderers-0.1.10.dev1}/renderers/configs.py

@@ -505,6 +505,28 @@ class LagunaXS2RendererConfig(BaseRendererConfig):
     chat template's ``render_assistant_messages_raw`` gate."""
 
 
+class LagunaM1RendererConfig(BaseRendererConfig):
+    """Laguna M.1 renderer config.
+
+    Laguna M.1 shares Laguna XS.2's role and tool-call format, but its
+    official checkpoint has a distinct chat template: it does not inject
+    XS.2's fallback system message and it gives ``message.reasoning``
+    precedence over ``message.reasoning_content``. Served by
+    :class:`renderers.laguna_xs2.LagunaM1Renderer`.
+    """
+
+    name: Literal["laguna-m.1"] = "laguna-m.1"
+
+    enable_thinking: bool = False
+    """When ``True``, the generation prompt includes ``<think>``. Mirrors
+    the official template's ``enable_thinking`` kwarg and default."""
+
+    render_assistant_messages_raw: bool = False
+    """When ``True``, assistant messages use the official template's
+    verbatim passthrough branch. See
+    :class:`LagunaXS2RendererConfig.render_assistant_messages_raw`."""
+
+
 class LagunaXS21RendererConfig(BaseRendererConfig):
     """Laguna XS-2.1 renderer config.
 
@@ -680,6 +702,7 @@ RendererConfig = Annotated[
         KimiK2RendererConfig,
         KimiK25RendererConfig,
         LagunaXS2RendererConfig,
+        LagunaM1RendererConfig,
         LagunaXS21RendererConfig,
         Llama3RendererConfig,
         MiniMaxM2RendererConfig,
@@ -720,6 +743,7 @@ _CONFIG_BY_NAME: dict[str, type[BaseRendererConfig]] = {
     "kimi-k2": KimiK2RendererConfig,
     "kimi-k2.5": KimiK25RendererConfig,
     "laguna-xs.2": LagunaXS2RendererConfig,
+    "laguna-m.1": LagunaM1RendererConfig,
     "laguna-xs-2.1": LagunaXS21RendererConfig,
     "llama-3": Llama3RendererConfig,
     "minimax-m2": MiniMaxM2RendererConfig,
@@ -767,6 +791,7 @@ __all__ = [
     "Hy3RendererConfig",
     "KimiK25RendererConfig",
     "KimiK2RendererConfig",
+    "LagunaM1RendererConfig",
     "LagunaXS2RendererConfig",
     "LagunaXS21RendererConfig",
     "Llama3RendererConfig",

{renderers-0.1.9.dev9 → renderers-0.1.10.dev1}/renderers/laguna_xs2.py

@@ -1,4 +1,4 @@
-"""Laguna-XS.2 / XS-2.1 Renderer.
+"""Poolside Laguna renderer family.
 
 Main properties:
 - Prefix is the single token ``〈|EOS|〉`` (also the EOS / stop token).
@@ -36,6 +36,11 @@ XS-2.1's template (upstream rev ``575f0f28``) is served by the
   section ends at ``</available_tools>``.
 - The ``<system>`` block is emitted whenever there is system content,
   tools, or ``enable_thinking`` — even if that leaves it empty.
+
+Laguna M.1's official template (revision ``2bf8a4ab``) is served by
+:class:`LagunaM1Renderer`. It shares XS.2's byte layout, tool syntax, and
+generation prompt, but has no fallback system prompt and reads assistant
+reasoning from ``reasoning`` before falling back to ``reasoning_content``.
 """
 
 from __future__ import annotations
@@ -56,7 +61,11 @@ from renderers.base import (
     resolve_thinking_retention,
     should_rerender_for_thinking_retention,
 )
-from renderers.configs import LagunaXS2RendererConfig, LagunaXS21RendererConfig
+from renderers.configs import (
+    LagunaM1RendererConfig,
+    LagunaXS2RendererConfig,
+    LagunaXS21RendererConfig,
+)
 from renderers.parsing import parse_laguna_xs2
 
 _DEFAULT_SYSTEM_MESSAGE = (
@@ -107,7 +116,12 @@ class LagunaXS2Renderer:
     def __init__(
         self,
         tokenizer: PreTrainedTokenizer,
-        config: LagunaXS2RendererConfig | LagunaXS21RendererConfig | None = None,
+        config: (
+            LagunaXS2RendererConfig
+            | LagunaM1RendererConfig
+            | LagunaXS21RendererConfig
+            | None
+        ) = None,
     ):
         self._tokenizer = tokenizer
         self.config = config or LagunaXS2RendererConfig()
@@ -481,12 +495,9 @@ class LagunaXS2Renderer:
         emit_text,
         emit_text_segments,
     ) -> None:
-        # Raw passthrough is an XS.2-only template gate; the XS-2.1
-        # config doesn't define it.
-        if (
-            isinstance(self.config, LagunaXS2RendererConfig)
-            and self.config.render_assistant_messages_raw
-        ):
+        # Raw passthrough is shared by XS.2 and M.1; XS-2.1's config does
+        # not expose this template gate.
+        if getattr(self.config, "render_assistant_messages_raw", False):
             self._render_assistant_raw(
                 msg_idx,
                 content,
@@ -495,16 +506,7 @@ class LagunaXS2Renderer:
             )
             return
 
-        reasoning_content = ""
-        if isinstance(msg.get("reasoning_content"), str):
-            reasoning_content = msg["reasoning_content"]
-        else:
-            # When the caller stores reasoning as a ``ThinkingPart`` inside
-            # a list-form ``content`` (e.g. after parse_response →
-            # reserialize), pull it out here so it survives the re-render.
-            part_thinking = self._thinking_text(msg.get("content"))
-            if part_thinking:
-                reasoning_content = part_thinking
+        reasoning_content, content = self._assistant_reasoning_and_content(msg, content)
 
         # ``<assistant>\n`` is template-injected scaffolding — the chat
         # template emits these as the generation prompt at inference and
@@ -567,6 +569,22 @@ class LagunaXS2Renderer:
         emit_special(self._assistant_end, msg_idx, is_sampled=True, is_content=True)
         emit_text("\n", msg_idx, is_sampled=False, is_content=False)
 
+    def _assistant_reasoning_and_content(
+        self, msg: Message, content: str
+    ) -> tuple[str, str]:
+        """Return the reasoning/body pair used by the XS.2 template."""
+        reasoning_content = ""
+        if isinstance(msg.get("reasoning_content"), str):
+            reasoning_content = msg["reasoning_content"]
+        else:
+            # When the caller stores reasoning as a ``ThinkingPart`` inside
+            # a list-form ``content`` (e.g. after parse_response →
+            # reserialize), pull it out here so it survives the re-render.
+            part_thinking = self._thinking_text(msg.get("content"))
+            if part_thinking:
+                reasoning_content = part_thinking
+        return reasoning_content, content
+
     def _render_assistant_raw(
         self,
         msg_idx: int,
@@ -620,6 +638,43 @@ class LagunaXS2Renderer:
         emit_text("\n", msg_idx, is_sampled=False, is_content=False)
 
 
+class LagunaM1Renderer(LagunaXS2Renderer):
+    """Renderer for the official ``poolside/Laguna-M.1`` checkpoint.
+
+    The token protocol is shared with XS.2, while the absent fallback
+    system prompt and assistant-reasoning precedence are M.1-specific.
+    """
+
+    def __init__(
+        self,
+        tokenizer: PreTrainedTokenizer,
+        config: LagunaM1RendererConfig | None = None,
+    ):
+        super().__init__(tokenizer, config or LagunaM1RendererConfig())
+        self._default_system_message = ""
+
+    def _assistant_reasoning_and_content(
+        self, msg: Message, content: str
+    ) -> tuple[str, str]:
+        # Match the official Jinja exactly: ``reasoning`` wins whenever it
+        # is a string (including the empty string), then
+        # ``reasoning_content`` is considered. An inline </think> block is
+        # removed from content and becomes the fallback reasoning source.
+        reasoning_content = ""
+        if isinstance(msg.get("reasoning"), str):
+            reasoning_content = msg["reasoning"]
+        elif isinstance(msg.get("reasoning_content"), str):
+            reasoning_content = msg["reasoning_content"]
+
+        if "</think>" in content:
+            if not reasoning_content:
+                before_close = content.split("</think>", 1)[0].rstrip("\n")
+                reasoning_content = before_close.split("<think>")[-1].lstrip("\n")
+            content = content.rsplit("</think>", 1)[-1].lstrip("\n")
+
+        return reasoning_content, content
+
+
 class LagunaXS21Renderer(LagunaXS2Renderer):
     """Laguna-XS-2.1 — mirrors the ``poolside/Laguna-XS-2.1`` chat
     template (upstream rev ``575f0f28``); see the module docstring for

{renderers-0.1.9.dev9 → renderers-0.1.10.dev1}/tests/conftest.py

@@ -37,6 +37,7 @@ RENDERER_MODELS = [
     # name (auto → MODEL_RENDERER_MAP → nemotron-3-ultra).
     ("nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B-BF16", "auto"),
     ("poolside/Laguna-XS.2", "auto"),
+    ("poolside/Laguna-M.1", "auto"),
     # XS-2.1 resolves to `LagunaXS21Renderer` via the model name — its
     # chat template differs from XS.2's (see renderers/laguna_xs2.py).
     ("poolside/Laguna-XS-2.1", "auto"),

renderers-0.1.10.dev1/tests/test_laguna_m1.py

@@ -0,0 +1,232 @@
+"""Exact chat-template parity for the official Laguna M.1 checkpoint."""
+
+from __future__ import annotations
+
+from functools import lru_cache
+
+import pytest
+from pydantic import TypeAdapter
+
+from renderers import (
+    LagunaM1Renderer,
+    LagunaM1RendererConfig,
+    RendererConfig,
+    create_renderer,
+)
+from renderers.base import load_tokenizer
+
+_MODEL = "poolside/Laguna-M.1"
+
+TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "shell",
+            "description": "Run a shell command",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "cmd": {"type": "string"},
+                    "timeout": {"type": "integer"},
+                },
+                "required": ["cmd"],
+            },
+        },
+    }
+]
+
+
+@lru_cache(maxsize=None)
+def _tok():
+    return load_tokenizer(_MODEL)
+
+
+def _renderer(**kwargs) -> LagunaM1Renderer:
+    renderer = create_renderer(_tok(), LagunaM1RendererConfig(**kwargs))
+    assert isinstance(renderer, LagunaM1Renderer)
+    return renderer
+
+
+def _expected(messages, *, tools=None, add_generation_prompt=False, **kwargs):
+    return list(
+        _tok().apply_chat_template(
+            messages,
+            tools=tools,
+            add_generation_prompt=add_generation_prompt,
+            tokenize=True,
+            return_dict=False,
+            **kwargs,
+        )
+    )
+
+
+def test_auto_selection_and_typed_config():
+    renderer = create_renderer(_tok())
+    assert isinstance(renderer, LagunaM1Renderer)
+    assert isinstance(renderer.config, LagunaM1RendererConfig)
+
+    parsed = TypeAdapter(RendererConfig).validate_python(
+        {"name": "laguna-m.1", "enable_thinking": True}
+    )
+    assert isinstance(parsed, LagunaM1RendererConfig)
+    assert parsed.enable_thinking is True
+
+
+@pytest.mark.parametrize("enable_thinking", [False, True])
+def test_no_system_and_generation_prompt_parity(enable_thinking):
+    messages = [{"role": "user", "content": "  preserve me  "}]
+    renderer = _renderer(enable_thinking=enable_thinking)
+    got = renderer.render_ids(messages, add_generation_prompt=True)
+    assert got == _expected(
+        messages,
+        add_generation_prompt=True,
+        enable_thinking=enable_thinking,
+    )
+
+    text = _tok().decode(got)
+    assert text.startswith("〈|EOS|〉<user>\n  preserve me  \n</user>\n<assistant>\n")
+    assert "<system>" not in text
+    assert text.endswith("<think>" if enable_thinking else "</think>")
+
+
+@pytest.mark.parametrize("enable_thinking", [False, True])
+def test_reasoning_content_history_parity_in_both_modes(enable_thinking):
+    messages = [
+        {"role": "user", "content": "Compute."},
+        {
+            "role": "assistant",
+            "reasoning_content": "\n  two steps  \n",
+            "content": "\n  result  \n",
+        },
+    ]
+    got = _renderer(enable_thinking=enable_thinking).render_ids(messages)
+    assert got == _expected(messages, enable_thinking=enable_thinking)
+    assert "<think>\ntwo steps\n</think>\nresult\n</assistant>\n" in _tok().decode(got)
+
+
+def test_reasoning_field_precedence_and_inline_think_extraction():
+    precedence = [
+        {"role": "user", "content": "Compute."},
+        {
+            "role": "assistant",
+            "reasoning": "preferred",
+            "reasoning_content": "ignored",
+            "content": "answer",
+        },
+    ]
+    got = _renderer(enable_thinking=True).render_ids(precedence)
+    assert got == _expected(precedence, enable_thinking=True)
+    text = _tok().decode(got)
+    assert "preferred" in text
+    assert "ignored" not in text
+
+    empty_reasoning_wins = [
+        {"role": "user", "content": "Compute."},
+        {
+            "role": "assistant",
+            "reasoning": "",
+            "reasoning_content": "also ignored",
+            "content": "answer",
+        },
+    ]
+    got = _renderer(enable_thinking=True).render_ids(empty_reasoning_wins)
+    assert got == _expected(empty_reasoning_wins, enable_thinking=True)
+    assert "also ignored" not in _tok().decode(got)
+
+    inline = [
+        {"role": "user", "content": "Compute."},
+        {
+            "role": "assistant",
+            "content": "<think>\ninline reason\n</think>\nvisible answer",
+        },
+    ]
+    assert _renderer().render_ids(inline) == _expected(inline)
+
+
+def test_tools_calls_responses_and_generation_prompt_parity():
+    messages = [
+        {"role": "system", "content": "Use tools carefully."},
+        {"role": "user", "content": "Inspect the machine."},
+        {
+            "role": "assistant",
+            "reasoning": "Need a command.",
+            "content": "Running it.",
+            "tool_calls": [
+                {
+                    "id": "call_1",
+                    "type": "function",
+                    "function": {
+                        "name": "shell",
+                        "arguments": {"cmd": "uname -a", "timeout": 5},
+                    },
+                }
+            ],
+        },
+        {
+            "role": "tool",
+            "tool_call_id": "call_1",
+            "content": '{"stdout":"Linux"}',
+        },
+    ]
+    renderer = _renderer(enable_thinking=True)
+    got = renderer.render_ids(messages, tools=TOOLS, add_generation_prompt=True)
+    assert got == _expected(
+        messages,
+        tools=TOOLS,
+        add_generation_prompt=True,
+        enable_thinking=True,
+    )
+
+    text = _tok().decode(got)
+    assert "<available_tools>\n" in text
+    assert (
+        "<tool_call>shell\n<arg_key>cmd</arg_key>\n"
+        "<arg_value>uname -a</arg_value>\n<arg_key>timeout</arg_key>\n"
+        "<arg_value>5</arg_value>\n</tool_call>\n"
+    ) in text
+    assert '<tool_response>\n{"stdout":"Linux"}\n</tool_response>\n' in text
+    assert text.endswith("<assistant>\n<think>")
+
+
+def test_reasoning_content_and_tool_call_round_trip():
+    renderer = _renderer(enable_thinking=True)
+    prompt = [{"role": "user", "content": "Inspect the machine."}]
+    assistant = {
+        "role": "assistant",
+        "reasoning": "Need a command.",
+        "content": "Running it.",
+        "tool_calls": [
+            {
+                "function": {
+                    "name": "shell",
+                    "arguments": {"cmd": "uname -a", "timeout": 5},
+                }
+            }
+        ],
+    }
+    prompt_ids = renderer.render_ids(prompt, add_generation_prompt=True)
+    full_ids = renderer.render_ids([*prompt, assistant])
+    completion_ids = full_ids[len(prompt_ids) :]
+    parsed = renderer.parse_response(completion_ids, tools=TOOLS)
+
+    assert parsed.reasoning_content == "Need a command."
+    assert parsed.content == "Running it."
+    assert len(parsed.tool_calls) == 1
+    assert parsed.tool_calls[0].name == "shell"
+    assert parsed.tool_calls[0].arguments == {"cmd": "uname -a", "timeout": 5}
+
+
+def test_raw_assistant_round_trip_parity():
+    messages = [
+        {"role": "user", "content": "Continue."},
+        {
+            "role": "assistant",
+            "content": "<think>raw reason</think>raw body</assistant>",
+        },
+    ]
+    renderer = _renderer(enable_thinking=True, render_assistant_messages_raw=True)
+    assert renderer.render_ids(messages) == _expected(
+        messages,
+        enable_thinking=True,
+        render_assistant_messages_raw=True,
+    )

{renderers-0.1.9.dev9 → renderers-0.1.10.dev1}/tests/test_renderer_config_parity.py

@@ -64,6 +64,7 @@ _RENDERER_MODELS = [
     # name; parity asserted against the Ultra apply_chat_template (``medium_effort``).
     ("nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B-BF16", "auto"),
     ("poolside/Laguna-XS.2", "auto"),
+    ("poolside/Laguna-M.1", "auto"),
     ("poolside/Laguna-XS-2.1", "auto"),
     ("tencent/Hy3", "auto"),
     ("openai/gpt-oss-20b", "gpt-oss"),
@@ -119,7 +120,7 @@ _KWARG_VALUES: dict[str, list[Any]] = {
         "You are a helpful assistant. Your name is MiniMax-M2.5 and is built by MiniMax.",
         "You are CustomBot, a research assistant.",
     ],
-    # Laguna-XS.2 — switches assistant rendering to a verbatim
+    # Laguna-XS.2 / Laguna-M.1 — switches assistant rendering to a verbatim
     # passthrough mode. The renderer paths diverge significantly under
     # this flag, so both values are exercised.
     "render_assistant_messages_raw": [True, False],

{renderers-0.1.9.dev9 → renderers-0.1.10.dev1}/tests/test_roundtrip.py

@@ -47,6 +47,7 @@ _ROUNDTRIP_MODELS = [
     # (no separating newline) — the Ultra-specific glue stresses the round-trip.
     ("nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B-BF16", "auto"),
     ("poolside/Laguna-XS.2", "auto"),
+    ("poolside/Laguna-M.1", "auto"),
     # Laguna-XS-2.1 is deliberately absent: under the default
     # ``enable_thinking=False`` its template drops assistant reasoning at
     # render time, so the reasoning round-trip can't hold by design.