[None][fix] MiniMax-M3: resolve an unprefilled prompt as outside reasoning (#20837)

Signed-off-by: Pranav Shrestha <254760092+pranav-nvidia@users.noreply.github.com>
Co-authored-by: Pranav Shrestha <254760092+pranav-nvidia@users.noreply.github.com>

Author: pranav-nvidia

tensorrt_llm/llmapi/reasoning_parser.py

@@ -116,6 +116,9 @@ def resolve_prefilled_thinking(cls, reasoning_parser: str,
                     parser, parser has not opted in, or neither marker is at
                     the tail). Callers must treat this as "ask elsewhere"
                     (e.g. the relayed disagg value), not as thinking-off.
+            A prompt ending with neither marker is referred to the parser's
+            `resolve_unmarked_prompt`, which returns None unless the parser
+            recognises the tail.
         """
         entry = cls._parsers.get(reasoning_parser.lower())
         if entry is None:
@@ -129,7 +132,7 @@ def resolve_prefilled_thinking(cls, reasoning_parser: str,
             return False
         if tail.endswith(parser_cls.reasoning_start):
             return True
-        return None
+        return parser_cls.resolve_unmarked_prompt(tail)
 
     @classmethod
     def keys(cls) -> KeysView[str]:
@@ -163,6 +166,15 @@ class BaseReasoningParser(ABC):
     reasoning_start: ClassVar[str]
     reasoning_end: ClassVar[str]
 
+    @classmethod
+    def resolve_unmarked_prompt(cls, tail: str) -> Optional[bool]:
+        """Mode of a rendered prompt whose stripped tail ends with neither marker.
+
+        None leaves the mode unresolved, which is right for a template that
+        prefills a marker whenever it prefills anything at all.
+        """
+        return None
+
     def __init__(self,
                  *,
                  chat_template_kwargs: Optional[dict[str, Any]] = None) -> None:
@@ -542,35 +554,46 @@ class MiniMaxM3ReasoningParser(DeepSeekR1Parser):
     tag; with thinking disabled it prefills ``</mm:think>``, so the output is
     all content; in adaptive mode (the template default) it prefills nothing
     and the model emits ``<mm:think>`` or the bare sentinel first. The parser
-    therefore takes its mode from an explicit ``thinking_mode`` or from the
-    mode the server resolved off the rendered prompt (relayed as
-    ``enable_thinking``), and otherwise starts outside reasoning. Both
-    tags are delimiters and never appear in the result; text before an
-    opening tag is content; an opening tag without a closing tag is
-    reasoning cut off by the token limit. ``parse`` and ``parse_delta``
-    agree on every input for every chunking.
+    takes its mode from the one the server resolved off the rendered prompt
+    (relayed as ``enable_thinking``), falls back to ``thinking_mode`` when
+    nothing was resolved, and otherwise starts outside reasoning. Both tags
+    are delimiters and never appear in the result; text before an opening tag
+    is content; an opening tag without a closing tag is reasoning cut off by
+    the token limit. ``parse`` and ``parse_delta`` agree for every chunking.
     """
 
     resolves_thinking_from_prompt = True
     reasoning_start = "<mm:think>"
     reasoning_end = "</mm:think>"
+    # The template's generation prompt is ``bos_token ~ 'ai' ~ '\\n'``.
+    _assistant_header = "]~b]ai"
+
+    @classmethod
+    def resolve_unmarked_prompt(cls, tail: str) -> Optional[bool]:
+        # Adaptive mode prefills nothing after the header, so the output
+        # starts outside reasoning. Any other unmarked tail, such as a custom
+        # template that prefills text after ``<mm:think>``, carries no mode the
+        # tail can read and is left to ``thinking_mode``.
+        if tail.endswith(cls._assistant_header):
+            return False
+        return None
 
     def __init__(self,
                  *,
                  chat_template_kwargs: Optional[dict[str, Any]] = None) -> None:
         kwargs = chat_template_kwargs or {}
-        # The template's own knob is `thinking_mode`; only "enabled" prefills
-        # the opening tag. Without it, trust the mode the server resolved
-        # from the rendered prompt, relayed as `enable_thinking` (a caller
-        # cannot pass that key: the template never reads it, so the
-        # unused-kwargs guard rejects it). A bare `thinking` is what the
-        # Responses path injects for `reasoning.effort`; this template does
-        # not act on it, so neither does the parser.
+        # The server overwrites `enable_thinking` with the mode resolved from
+        # the rendered prompt, so it wins over `thinking_mode`, which decides
+        # only when nothing was resolved. The Responses path's bare `thinking`
+        # is ignored because the template never reads it.
+        resolved = kwargs.get("enable_thinking")
         thinking_mode = kwargs.get("thinking_mode")
-        if thinking_mode is not None:
+        if resolved is not None:
+            prefilled_open = resolved is True
+        elif thinking_mode is not None:
             prefilled_open = thinking_mode == "enabled"
         else:
-            prefilled_open = kwargs.get("enable_thinking") is True
+            prefilled_open = False
         super().__init__(reasoning_at_start=prefilled_open,
                          chat_template_kwargs=chat_template_kwargs)
         self.reasoning_start = "<mm:think>"

tests/unittest/llmapi/apps/test_reasoning_prompt_resolution.py

@@ -60,13 +60,16 @@ def render(chat_template_kwargs: dict | None, add_generation_prompt: bool = True
 
 
 def build_args(
-    rendered_prompt: str | None, request_kwargs: dict | None, add_generation_prompt: bool = True
+    rendered_prompt: str | None,
+    request_kwargs: dict | None,
+    add_generation_prompt: bool = True,
+    reasoning_parser: str = "poolside_v1",
 ) -> ChatPostprocArgs:
     """Mirror what `openai_server` does after rendering the prompt."""
     args = ChatPostprocArgs(
         role="assistant", model="test-model", chat_template_kwargs=request_kwargs
     )
-    args.reasoning_parser = "poolside_v1"
+    args.reasoning_parser = reasoning_parser
     args.num_prompt_tokens = 3
     if args.reasoning_parser and rendered_prompt and add_generation_prompt:
         thinking = ReasoningParserFactory.resolve_prefilled_thinking(
@@ -208,3 +211,46 @@ def test_unrendered_prompt_falls_back_without_crashing() -> None:
     # Unresolved, so the pre-existing split on an emitted `<think>` applies.
     assert content == "c"
     assert reasoning == "b"
+
+
+# MiniMax-M3 adaptive mode: the prompt ends at the assistant header and the model emits its tags.
+M3_ADAPTIVE_PROMPT = "]~b]user\nhi[e~[\n]~b]ai\n"
+M3_OUTPUT = "<mm:think>hidden</mm:think>visible"
+
+
+@pytest.mark.parametrize(
+    "request_kwargs",
+    [
+        # Injected by the Anthropic adapter for `thinking: {"type": "enabled"}`.
+        {"enable_thinking": True},
+        # Passed by a caller with the unused-kwargs guard relaxed.
+        {"thinking_mode": "enabled"},
+    ],
+)
+def test_minimax_m3_adaptive_prompt_ignores_request_thinking_flag(request_kwargs: dict) -> None:
+    """A thinking flag that the prompt does not reflect must not open a block."""
+    args = build_args(M3_ADAPTIVE_PROMPT, request_kwargs, reasoning_parser="minimax_m3")
+
+    content, reasoning = apply_reasoning_parser(args, 0, M3_OUTPUT, streaming=False)
+
+    assert (content, reasoning) == ("visible", "hidden")
+
+
+def test_minimax_m3_prefilled_reasoning_text_is_left_to_thinking_mode() -> None:
+    """Text prefilled after `<mm:think>` is not the adaptive header: nothing is resolved."""
+    prompt = M3_ADAPTIVE_PROMPT + "<mm:think>Let me think."
+    args = build_args(prompt, {"thinking_mode": "enabled"}, reasoning_parser="minimax_m3")
+
+    content, reasoning = apply_reasoning_parser(
+        args, 0, "hidden</mm:think>visible", streaming=False
+    )
+
+    assert (content, reasoning) == ("visible", "hidden")
+
+
+def test_minimax_m3_context_worker_stamps_adaptive_prompt_as_off() -> None:
+    args = build_args(M3_ADAPTIVE_PROMPT, {"enable_thinking": True}, reasoning_parser="minimax_m3")
+
+    response = chat_response_post_processor(_FakeResult(M3_OUTPUT), args)
+
+    assert response.choices[0].disaggregated_params.resolved_thinking is False

tests/unittest/llmapi/apps/test_render_core.py

@@ -930,6 +930,11 @@ class TestPreparationContext:
         "{% if add_generation_prompt %}<assistant><think>{% endif %}"
     )
     PREFILLED_CLOSED = PREFILLED_OPEN.replace("<think>", "</think>")
+    # MiniMax-M3 in adaptive mode: the generation prompt is the bare assistant header.
+    M3_ADAPTIVE = (
+        "{% for m in messages %}]~b]{{ m.role }}\n{{ m.content }}[e~[\n{% endfor %}"
+        "{% if add_generation_prompt %}]~b]ai\n{% endif %}"
+    )
 
     def _context(self, template, **overrides):
         res = resources(make_tokenizer(chat_template=template), **overrides)
@@ -949,6 +954,10 @@ def test_a_prompt_that_closes_thinking_is_recorded_as_off(self) -> None:
     def test_a_prompt_that_prefills_nothing_records_nothing(self, tokenizer) -> None:
         assert render_chat(chat_request(), resources(tokenizer)).context["resolved_thinking"] == {}
 
+    def test_the_minimax_m3_adaptive_header_is_recorded_as_off(self) -> None:
+        # The template prefills nothing after its header, so only that parser resolves the prompt.
+        assert self._context(self.M3_ADAPTIVE)["resolved_thinking"] == {"minimax_m3": False}
+
     def test_no_generation_prompt_records_nothing(self) -> None:
         res = resources(make_tokenizer(chat_template=self.PREFILLED_OPEN))
 

tests/unittest/llmapi/test_reasoning_parser.py

@@ -548,7 +548,7 @@ def test_resolved_mode_overrides_whatever_the_caller_sent(
 
 @pytest.mark.parametrize("parser", [
     "deepseek-r1", "deepseek_v4", "deepseek_v41", "qwen3", "qwen3_5",
-    "minimax_m2", "minimax_m3", "gemma4", "kimi_k2", "kimi_k25"
+    "minimax_m2", "gemma4", "kimi_k2", "kimi_k25"
 ])
 def test_resolve_prefilled_thinking_requires_opt_in(parser: str) -> None:
     """Parsers that have not opted in must never be resolved from the prompt.
@@ -1505,6 +1505,15 @@ def _m3_parser(kwargs: dict | None):
         ({
             "thinking": True
         }, f"{M3_START}a{M3_END}b", "b", "a"),
+        # The mode resolved from the rendered prompt wins over `thinking_mode`.
+        ({
+            "thinking_mode": "enabled",
+            "enable_thinking": False
+        }, f"{M3_START}a{M3_END}b", "b", "a"),
+        ({
+            "thinking_mode": "disabled",
+            "enable_thinking": True
+        }, f"a{M3_END}b", "b", "a"),
     ])
 def test_minimax_m3_reasoning_parser(kwargs: dict | None, text: str,
                                      content: str,
@@ -1514,6 +1523,34 @@ def test_minimax_m3_reasoning_parser(kwargs: dict | None, text: str,
     assert result.reasoning_content == reasoning_content
 
 
+# The official template: ``bos_token ~ role``, ``eos_token`` after each
+# message, and ``]~b]ai`` as the generation prompt.
+M3_HEADER = "]~b]ai\n"
+M3_PROMPT = f"]~b]user\nhi[e~[\n{M3_HEADER}"
+
+
+@pytest.mark.parametrize(
+    ("prompt", "expected"),
+    [
+        (f"{M3_PROMPT}{M3_START}", True),
+        (f"{M3_PROMPT}{M3_END}", False),
+        # Adaptive: nothing after the header, so the output starts outside
+        # reasoning even though a prior turn rendered its own tags.
+        (M3_PROMPT, False),
+        (f"]~b]ai\n{M3_START}a{M3_END}b[e~[\n]~b]user\nmore[e~[\n{M3_HEADER}",
+         False),
+        # Prefilled text after the opening tag is not adaptive; the tail carries
+        # no mode it can read, so `thinking_mode` decides.
+        (f"{M3_PROMPT}{M3_START}Let me think.", None),
+        # A custom template that ends elsewhere is left unresolved as before.
+        ("<user>hi</user>\n<assistant>", None),
+    ])
+def test_minimax_m3_resolves_the_prompt_tail(prompt: str,
+                                             expected: bool | None) -> None:
+    assert ReasoningParserFactory.resolve_prefilled_thinking(
+        "minimax_m3", prompt) is expected
+
+
 def _m3_stream(kwargs: dict | None, chunks: list[str]) -> tuple[str, str]:
     reasoning_parser = _m3_parser(kwargs)
     content, reasoning_content = "", ""