Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
Studio: keep literal <think> text visible when the request turns thinking off (#10662)
Nilay1ceffa74a90d
diff --git a/studio/backend/routes/inference.py b/studio/backend/routes/inference.pyindex 5cb499c8e14..4162b2eff63 100644--- a/studio/backend/routes/inference.py+++ b/studio/backend/routes/inference.py@@ -3718,6 +3718,33 @@ def _sf_reasoning_prefill_mode(return _generation_prompt_opens_think(tpl, enable_thinking, reasoning_effort, messages)+def _sf_parse_think_markers(+ features: dict,+ enable_thinking: Optional[bool] = None,+ reasoning_effort: Optional[str] = None,+) -> bool:+ """Whether <think> markup in a safetensors/MLX reply can be genuine reasoning.++ Both raw fields reach the template, which reads only the dial it branches on; a+ hybrid sent both reads enable_thinking first (Kimi-K3).+ """+ if features.get("reasoning_always_on"):+ return True+ if not features.get("supports_reasoning"):+ return False+ style = features.get("reasoning_style")+ resolved: dict = {}+ if style == "reasoning_effort":+ if reasoning_effort is not None:+ resolved["reasoning_effort"] = reasoning_effort+ elif enable_thinking is not None:+ resolved["enable_thinking"] = enable_thinking+ elif style == "enable_thinking_effort" and reasoning_effort is not None:+ resolved["reasoning_effort"] = reasoning_effort+ # No launch default on this backend: an empty dict leaves the template's own.+ return _resolved_kwargs_think(None, resolved)++def _effective_enable_tools(payload) -> Optional[bool]:"""Resolve `payload.enable_tools` against the process-level tool policy.@@ -4241,6 +4268,25 @@ def _anthropic_preserve_thinking(llama_backend, payload) -> bool:return bool(getattr(llama_backend, "preserve_thinking_default", False))+def _resolved_kwargs_think(llama_backend, resolved) -> bool:+ """Whether the resolved template kwargs leave thinking on.++ Effort dials think at every level except "none", which Inkling's+ _coerce_reasoning_effort rewrites to numeric 0. With no kwargs the model+ runs on the default it was launched with.+ """+ if "enable_thinking" in resolved:+ return bool(resolved["enable_thinking"])+ if "reasoning_effort" in resolved:+ effort = resolved["reasoning_effort"]+ if isinstance(effort, str):+ return effort.strip().lower() != "none"+ if isinstance(effort, (int, float)) and not isinstance(effort, bool):+ return float(effort) != 0.0+ return True+ return bool(getattr(llama_backend, "reasoning_default", True))++def _think_parsing_expected(llama_backend, payload) -> bool:"""Whether <think> markup in this reply can be genuine reasoning.@@ -4269,13 +4315,7 @@ def _think_parsing_expected(llama_backend, payload) -> bool:)or {})- if "enable_thinking" in resolved:- return bool(resolved["enable_thinking"])- if "reasoning_effort" in resolved:- # Effort-dial templates think at every level except "none".- return resolved["reasoning_effort"] != "none"- # No explicit kwargs: the template's own default decides whether it thinks.- return bool(getattr(llama_backend, "reasoning_default", True))+ return _resolved_kwargs_think(llama_backend, resolved)def _anthropic_count_template_kwargs(llama_backend, payload):@@ -24285,6 +24325,11 @@ async def produce_openai_chat_completions(except Exception:_sf_probe_messages = None+ # Transformers vision generation drops both reasoning fields; MLX forwards them.+ _sf_vision_drops_reasoning = image is not None and not _sf_model_info.get("is_mlx", False)+ _sf_gate_enable_thinking = None if _sf_vision_drops_reasoning else payload.enable_thinking+ _sf_gate_reasoning_effort = None if _sf_vision_drops_reasoning else payload.reasoning_effort+def _sf_response_protocol(tools = None,template = None,@@ -24309,8 +24354,10 @@ async def produce_openai_chat_completions(body = _selected[0]except Exception:logger.debug("safetensors_prefill_template_selection_failed", exc_info = True)- parse_think = bool(- features.get("supports_reasoning") or features.get("reasoning_always_on")+ parse_think = _sf_parse_think_markers(+ features,+ _sf_gate_enable_thinking,+ _sf_gate_reasoning_effort,)reasoning_prefilled = _sf_reasoning_prefill_mode(features,@@ -27917,9 +27964,19 @@ def _responses_should_parse_think_markers(if llama_backend is not None and getattr(llama_backend, "is_loaded", False):if getattr(llama_backend, "reasoning_always_on", False):return True- if getattr(llama_backend, "supports_reasoning", False):- return True- return False+ if not getattr(llama_backend, "supports_reasoning", False):+ return False+ # Same rule as _think_parsing_expected: decide from the resolved kwargs.+ resolved = (+ _reasoning_template_kwargs(+ llama_backend,+ chat_req.enable_thinking,+ chat_req.reasoning_effort,+ chat_req.preserve_thinking,+ )+ or {}+ )+ return _resolved_kwargs_think(llama_backend, resolved)if chat_req.enable_thinking is True:return Truereturn chat_req.enable_thinking is None and chat_req.reasoning_effort not in (None, "none")diff --git a/studio/backend/tests/test_anthropic_messages.py b/studio/backend/tests/test_anthropic_messages.pyindex 756954a8793..3b52f722d5e 100644--- a/studio/backend/tests/test_anthropic_messages.py+++ b/studio/backend/tests/test_anthropic_messages.py@@ -216,6 +216,20 @@ def test_think_parsing_expected_gates_on_capability_and_request():_think_parsing_expected(_EffortBackend(), _basic_payload(reasoning_effort = "none")) is False)+ # Inkling: _coerce_reasoning_effort rewrites the "none" sentinel to 0, so 0 reads as off.+ class _NumericEffortBackend(_Backend):+ def _request_reasoning_kwargs(self, enable_thinking, reasoning_effort, preserve_thinking):+ return {"reasoning_effort": 0.0 if reasoning_effort == "none" else 0.2}++ assert (+ _think_parsing_expected(_NumericEffortBackend(), _basic_payload(reasoning_effort = "none"))+ is False+ )+ assert (+ _think_parsing_expected(_NumericEffortBackend(), _basic_payload(enable_thinking = False))+ is True+ )+def test_anthropic_reasoning_args_maps_effort_only_to_enable_thinking():# Effort-only requests must drive enable_thinking-style templates the samediff --git a/studio/backend/tests/test_openai_tool_passthrough.py b/studio/backend/tests/test_openai_tool_passthrough.pyindex d79c8640dc1..61637ed5eca 100644--- a/studio/backend/tests/test_openai_tool_passthrough.py+++ b/studio/backend/tests/test_openai_tool_passthrough.py@@ -5046,24 +5046,47 @@ class TestGgufVisionToolRouting:[entry] = result.monitor.snapshot()assert entry["reply"] == "visible"- def test_reasoning_capable_gguf_stream_sanitizes_think_tags_when_disabled(self, monkeypatch):+ def test_reasoning_capable_gguf_stream_keeps_think_tags_visible_when_disabled(+ self, monkeypatch+ ):+ answer = "Use <think>hi</think> in your prompt."+def _generate(**_kwargs):- yield "<think>leaked</think>visible"+ yield answeryield _stop_metadata()result = self._run_gguf_case(monkeypatch,generate = _generate,- payload_kwargs = {"stream": True, "enable_thinking": False},+ # The shape Studio's own composer sends for an enable_thinking template+ # once the Thinking toggle is off.+ payload_kwargs = {"stream": True, "thinking": {"type": "disabled"}},backend_kwargs = {"reasoning_always_on": False},)deltas = [p["choices"][0].get("delta", {}) for p in result.payloads if p.get("choices")]- assert "".join(d.get("reasoning_content", "") for d in deltas) == "leaked"- assert "".join(d.get("content", "") for d in deltas) == "visible"- assert all("<think>" not in d.get("content", "") for d in deltas)+ assert "".join(d.get("reasoning_content", "") for d in deltas) == ""+ assert "".join(d.get("content", "") for d in deltas) == answer[entry] = result.monitor.snapshot()- assert entry["reply"] == "visible"+ assert entry["reply"] == answer++ def test_reasoning_capable_gguf_keeps_think_tags_visible_when_disabled(self, monkeypatch):+ answer = "Use <think>hi</think> in your prompt."++ def _generate(**_kwargs):+ yield answer+ yield _stop_metadata()++ result = self._run_gguf_case(+ monkeypatch,+ generate = _generate,+ payload_kwargs = {"enable_thinking": False},+ backend_kwargs = {"reasoning_always_on": False},+ )+ message = result.body["choices"][0]["message"]++ assert message["content"] == answer+ assert message.get("reasoning_content") is Nonedef test_gguf_tool_stream_splits_reasoning_and_strips_gemma_tool_marker(self, monkeypatch):def _tools(**_kwargs):diff --git a/studio/backend/tests/test_responses_tool_passthrough.py b/studio/backend/tests/test_responses_tool_passthrough.pyindex ae0ff0cb921..db788d676c8 100644--- a/studio/backend/tests/test_responses_tool_passthrough.py+++ b/studio/backend/tests/test_responses_tool_passthrough.py@@ -1949,11 +1949,11 @@ class TestResponsesNonStreamingAdapter:assert body["output"][0]["content"] == [{"type": "reasoning_text", "text": "plan"}]assert body["output"][1]["content"][0]["text"] == "answer"- def test_reasoning_capable_gguf_sanitizes_think_tags_when_disabled(self, monkeypatch):+ def test_reasoning_capable_gguf_keeps_think_tags_visible_when_disabled(self, monkeypatch):payload = ResponsesRequest(input = "hi", reasoning = {"effort": "none"})body = self._run_with_message(monkeypatch,- {"content": "<think>leaked</think>answer"},+ {"content": "Use <think>hi</think> in your prompt."},payload = payload,llama_backend = SimpleNamespace(is_loaded = True,@@ -1962,8 +1962,94 @@ class TestResponsesNonStreamingAdapter:),)+ assert [item["type"] for item in body["output"]] == ["message"]+ assert body["output"][0]["content"][0]["text"] == "Use <think>hi</think> in your prompt."++ def test_effort_dial_gguf_still_parses_think_tags_when_disabled(self, monkeypatch):+ payload = ResponsesRequest(input = "hi", reasoning = {"effort": "none"})+ body = self._run_with_message(+ monkeypatch,+ {"content": "<think>plan</think>answer"},+ payload = payload,+ llama_backend = SimpleNamespace(+ is_loaded = True,+ reasoning_always_on = False,+ supports_reasoning = True,+ # gpt-oss offers no "none" level, so it stays on low effort and the markup is real.+ _request_reasoning_kwargs = (+ lambda enable_thinking, reasoning_effort = None, preserve_thinking = None: (+ {"reasoning_effort": "low"}+ )+ ),+ ),+ )+assert [item["type"] for item in body["output"]] == ["reasoning", "message"]- assert body["output"][0]["content"] == [{"type": "reasoning_text", "text": "leaked"}]+ assert body["output"][0]["content"] == [{"type": "reasoning_text", "text": "plan"}]+ assert body["output"][1]["content"][0]["text"] == "answer"++ def test_inkling_numeric_zero_effort_keeps_think_tags_visible(self, monkeypatch):+ # Real resolver, not a stand-in: for Inkling, _coerce_reasoning_effort rewrites+ # the "none" sentinel to numeric 0, which a string-only check misreads as still on.+ from core.inference.llama_cpp import LlamaCppBackend++ backend = LlamaCppBackend.__new__(LlamaCppBackend)+ backend._process = object()+ backend._healthy = True+ backend._supports_reasoning = True+ backend._reasoning_always_on = False+ backend._reasoning_style = "reasoning_effort"+ backend._reasoning_effort_levels = ["none", "low", "medium", "high", "max"]+ backend._supports_preserve_thinking = False+ backend._preserve_thinking_default = False+ backend._reasoning_default = True+ backend._architecture = "inkling"++ assert backend._request_reasoning_kwargs(False, "none", None) == {"reasoning_effort": 0.0}++ payload = ResponsesRequest(input = "hi", reasoning = {"effort": "none"})+ body = self._run_with_message(+ monkeypatch,+ {"content": "Use <think>hi</think> in your prompt."},+ payload = payload,+ llama_backend = backend,+ )++ assert [item["type"] for item in body["output"]] == ["message"]+ assert body["output"][0]["content"][0]["text"] == "Use <think>hi</think> in your prompt."++ def test_launch_default_thinking_off_keeps_think_tags_visible(self, monkeypatch):+ # No reasoning field means no override, so the model runs on the default it was+ # launched with. The Qwen3.5 Small tier launches thinking off.+ body = self._run_with_message(+ monkeypatch,+ {"content": "Use <think>hi</think> in your prompt."},+ llama_backend = SimpleNamespace(+ is_loaded = True,+ reasoning_always_on = False,+ supports_reasoning = True,+ reasoning_default = False,+ ),+ )++ assert [item["type"] for item in body["output"]] == ["message"]+ assert body["output"][0]["content"][0]["text"] == "Use <think>hi</think> in your prompt."++ def test_launch_default_thinking_on_still_parses_think_tags(self, monkeypatch):+ # Mirror: a thinking-on launch default still splits, so the fix is not "never parse".+ body = self._run_with_message(+ monkeypatch,+ {"content": "<think>plan</think>answer"},+ llama_backend = SimpleNamespace(+ is_loaded = True,+ reasoning_always_on = False,+ supports_reasoning = True,+ reasoning_default = True,+ ),+ )++ assert [item["type"] for item in body["output"]] == ["reasoning", "message"]+ assert body["output"][0]["content"] == [{"type": "reasoning_text", "text": "plan"}]assert body["output"][1]["content"][0]["text"] == "answer"def test_structured_reasoning_content_extracts_text_parts(self, monkeypatch):diff --git a/studio/backend/tests/test_safetensors_reasoning_stream.py b/studio/backend/tests/test_safetensors_reasoning_stream.pyindex ab0e3891ee3..694bf72d096 100644--- a/studio/backend/tests/test_safetensors_reasoning_stream.py+++ b/studio/backend/tests/test_safetensors_reasoning_stream.py@@ -33,6 +33,7 @@ if _BACKEND_DIR not in sys.path:from routes.inference import (_ResponsesReasoningExtractor,+ _sf_parse_think_markers,_sf_reasoning_prefill_mode,_strip_tool_xml_for_display,)@@ -156,6 +157,7 @@ _STRICT_HISTORY_TPL = ("{% endif %}<|im_start|>{{ m['role'] }}\n{{ m['content'] }}<|im_end|>\n{% endfor %}""{% if add_generation_prompt %}<|im_start|>assistant\n<think>\n\n</think>\n\n{% endif %}")+_TINY_PNG_B64 = "iVBORw0KGgoAAAANSUhEUgAAAAQAAAAECAIAAAAmkwkpAAAAE0lEQVR4nGM8ISfHAANMcBZeDgA0dgEMydTl/QAAAABJRU5ErkJggg=="_ETHINK = {"reasoning_style": "enable_thinking", "supports_reasoning": True}_ETHINK_EFFORT = {"reasoning_style": "enable_thinking_effort", "supports_reasoning": True}@@ -613,7 +615,15 @@ def test_the_eager_import_under_the_stubs_actually_succeeded():assert "core.inference.inference" in sys.modules-def _sf_route_message(monkeypatch, template, snapshots, **body):+def _sf_route_message(+ monkeypatch,+ template,+ snapshots,+ is_vision = False,+ is_mlx = False,+ features = None,+ **body,+):"""POST a non-streaming safetensors chat completion and return the assistant message."""from fastapi import FastAPIfrom fastapi.testclient import TestClient@@ -628,7 +638,13 @@ def _sf_route_message(monkeypatch, template, snapshots, **body):class _Safetensors:active_model_name = "qwen"- models = {"qwen": {"chat_template_info": {"template": template}}}+ models = {+ "qwen": {+ "chat_template_info": {"template": template},+ "is_vision": is_vision,+ "is_mlx": is_mlx,+ }+ }def generate_chat_response(self, **kwargs):yield from snapshots@@ -636,10 +652,13 @@ def _sf_route_message(monkeypatch, template, snapshots, **body):def reset_generation_state(self, *_args):return None+ def resize_image(self, image):+ return image+monkeypatch.setattr(inference_route,"_detect_safetensors_features",- lambda backend, chat_template, tools = None: dict(_ETHINK, supports_tools = False),+ lambda backend, chat_template, tools = None: dict(features or _ETHINK, supports_tools = False),)monkeypatch.setattr(inference_route, "get_llama_cpp_backend", lambda: _NoGGUF())monkeypatch.setattr(inference_route, "get_inference_backend", lambda: _Safetensors())@@ -667,3 +686,93 @@ def test_route_returns_the_answer_as_content_when_the_template_closes_its_block(message = _sf_route_message(monkeypatch, _TEMPLATE_DEFAULT_OFF_TPL, snapshots)assert message["content"] == "The capital of Japan is Tokyo."assert not message["reasoning_content"]+++def test_route_keeps_literal_think_text_when_the_request_turns_thinking_off(monkeypatch):+ answer = "Use <think>hi</think> in your prompt."+ message = _sf_route_message(+ monkeypatch,+ _TEMPLATE_DEFAULT_OFF_TPL,+ [answer],+ enable_thinking = False,+ )+ assert message["content"] == answer+ assert not message["reasoning_content"]+++def test_route_still_splits_real_thinking_when_the_request_leaves_it_on(monkeypatch):+ message = _sf_route_message(+ monkeypatch,+ _TEMPLATE_DEFAULT_OFF_TPL,+ ["<think>plan</think>answer"],+ enable_thinking = True,+ )+ assert message["content"] == "answer"+ assert message["reasoning_content"] == "plan"+++def test_route_still_splits_a_transformers_image_turn_the_request_asked_to_disable(monkeypatch):+ """Transformers vision generation ignores both reasoning fields."""+ message = _sf_route_message(+ monkeypatch,+ _TEMPLATE_DEFAULT_OFF_TPL,+ ["<think>plan</think>answer"],+ is_vision = True,+ enable_thinking = False,+ image_base64 = _TINY_PNG_B64,+ )+ assert message["content"] == "answer"+ assert message["reasoning_content"] == "plan"+++def test_route_keeps_literal_think_text_on_an_mlx_image_turn(monkeypatch):+ """Effort alone, so a guard that drops it cannot pass on the boolean."""+ answer = "Use <think>hi</think> in your prompt."+ message = _sf_route_message(+ monkeypatch,+ _EFFORT_SHAPE_TPL,+ [answer],+ features = _ETHINK_EFFORT,+ is_vision = True,+ is_mlx = True,+ reasoning_effort = "none",+ image_base64 = _TINY_PNG_B64,+ )+ assert message["content"] == answer+ assert not message["reasoning_content"]+++def test_route_carries_the_effort_field_into_the_gate(monkeypatch):+ answer = "Use <think>hi</think> in your prompt."+ message = _sf_route_message(+ monkeypatch,+ _EFFORT_SHAPE_TPL,+ [answer],+ features = _ETHINK_EFFORT,+ reasoning_effort = "none",+ )+ assert message["content"] == answer+ assert not message["reasoning_content"]+++def test_parse_think_markers_gates_on_capability_and_request():+ assert _sf_parse_think_markers(_ETHINK) is True+ assert _sf_parse_think_markers(_ETHINK, True) is True+ assert _sf_parse_think_markers(_ETHINK, False) is False+ assert _sf_parse_think_markers(dict(_ETHINK, reasoning_always_on = True), False) is True+ assert _sf_parse_think_markers({"supports_reasoning": False}, True) is False+++def test_parse_think_markers_reads_only_the_dial_the_template_branches_on():+ # Plain enable_thinking templates ignore the effort.+ assert _sf_parse_think_markers(_ETHINK, None, "none") is True+ # Effort-only ladders ignore the boolean.+ _EFFORT_ONLY = {"reasoning_style": "reasoning_effort", "supports_reasoning": True}+ assert _sf_parse_think_markers(_EFFORT_ONLY, False, None) is True+ assert _sf_parse_think_markers(_EFFORT_ONLY, None, "none") is False+ assert _sf_parse_think_markers(_EFFORT_ONLY, None, "low") is True+ # Hybrid templates read enable_thinking first (Kimi-K3).+ assert _sf_parse_think_markers(_ETHINK_EFFORT, True, "none") is True+ assert _sf_parse_think_markers(_ETHINK_EFFORT, False, "high") is False+ assert _sf_parse_think_markers(_ETHINK_EFFORT, None, "none") is False+ assert _sf_parse_think_markers(_ETHINK_EFFORT, None, "high") is True