Skip to content

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.

Studio: clamp unsupported reasoning effort to offered levels (#12208)

oobabooga1a46fe179193
diff --git a/studio/backend/core/inference/llama_cpp.py b/studio/backend/core/inference/llama_cpp.py
index 9ba1453e73d..03dc68ade04 100644
--- a/studio/backend/core/inference/llama_cpp.py
+++ b/studio/backend/core/inference/llama_cpp.py
@@ -2729,6 +2729,31 @@ def _extract_reasoning_effort_levels(chat_template: str) -> list:
]
+# Log each substitution once per (levels, requested) pair.
+_REASONING_EFFORT_CLAMPS_LOGGED: set = set()
+
+
+def _clamp_reasoning_effort_to_levels(effort: Optional[str], levels) -> Optional[str]:
+ """Match the UI clamp: prefer the nearest lower level, then the weakest.
+
+ Use max for an unavailable xhigh if offered. Return None for an absent or
+ unknown effort or an empty ladder. See clampReasoningEffortToLevels in
+ studio/frontend/src/features/chat/provider-capabilities.ts.
+ """
+ if effort not in _REASONING_EFFORT_SCALE or not levels:
+ return None
+ if effort == "xhigh" and "xhigh" not in levels and "max" in levels:
+ effort = "max"
+ if effort in levels:
+ return effort
+ offered = [level for level in _REASONING_EFFORT_SCALE if level in levels and level != "none"]
+ if not offered:
+ return None
+ rank = _REASONING_EFFORT_SCALE.index(effort)
+ below = [level for level in offered if _REASONING_EFFORT_SCALE.index(level) < rank]
+ return below[-1] if below else offered[0]
+
+
# Headers already described in the log, keyed on identity rather than name so a rebuilt
# GGUF at the same path is described again. Bounded; a dropped entry only re-logs once.
_GGUF_METADATA_LOGGED: "dict[tuple, bool]" = {}
@@ -8088,14 +8113,29 @@ class LlamaCppBackend:
# 'low' effort the way gpt-oss does (those models genuinely
# cannot disable).
thinking_off = enable_thinking is False or reasoning_effort == "none"
+ # Clamp unsupported levels to avoid template defaults or errors.
+ effort = (
+ None
+ if thinking_off
+ else _clamp_reasoning_effort_to_levels(
+ reasoning_effort, self._reasoning_effort_levels
+ )
+ )
+ if effort is not None and effort != reasoning_effort:
+ key = (tuple(self._reasoning_effort_levels), reasoning_effort)
+ if key not in _REASONING_EFFORT_CLAMPS_LOGGED:
+ _REASONING_EFFORT_CLAMPS_LOGGED.add(key)
+ logger.info(
+ f"reasoning_effort '{reasoning_effort}' is not offered by this "
+ f"template {list(self._reasoning_effort_levels)}; using '{effort}'"
+ )
# A named effort level implies thinking on, so emit enable_thinking
# even if the caller sent only reasoning_effort (else the template
# defaults it off and the requested level never renders).
- effort_on = reasoning_effort in self._reasoning_effort_levels
- if enable_thinking is not None or reasoning_effort == "none" or effort_on:
+ if enable_thinking is not None or reasoning_effort == "none" or effort is not None:
kwargs["enable_thinking"] = not thinking_off
- if not thinking_off and effort_on:
- kwargs["reasoning_effort"] = reasoning_effort
+ if effort is not None:
+ kwargs["reasoning_effort"] = effort
elif self._reasoning_style == "reasoning_effort":
_levels = getattr(self, "_reasoning_effort_levels", None) or ()
if reasoning_effort in ("none", "low", "medium", "high") or (
diff --git a/studio/backend/tests/test_reasoning_effort_clamp.py b/studio/backend/tests/test_reasoning_effort_clamp.py
new file mode 100644
index 00000000000..6326861b6a8
--- /dev/null
+++ b/studio/backend/tests/test_reasoning_effort_clamp.py
@@ -0,0 +1,139 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Unsupported effort levels clamp to the template's offered levels, as in the UI."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+_backend_root = Path(__file__).resolve().parent.parent
+if str(_backend_root) not in sys.path:
+ sys.path.insert(0, str(_backend_root))
+
+
+# Earlier Qwen3.8 template: defaults to xhigh and rejects unsupported levels.
+QWEN38_EARLY_TEMPLATE = """
+{%- if enable_thinking is undefined or enable_thinking is true %}
+ {%- set resolved_reasoning_effort = reasoning_effort|default('xhigh') %}
+ {%- if resolved_reasoning_effort not in ('xhigh', 'medium', 'low') %}
+ {{- raise_exception('Unexpected reasoning effort ' ~ reasoning_effort) }}
+ {%- endif %}
+ {{- 'effort=' ~ resolved_reasoning_effort }}
+{%- else %}
+ {{- 'effort=off' }}
+{%- endif %}
+"""
+
+
+def _backend(template):
+ from core.inference.llama_cpp import LlamaCppBackend, detect_reasoning_flags
+
+ flags = detect_reasoning_flags(template, "vendor/Qwen3.8-27B-GGUF")
+ backend = object.__new__(LlamaCppBackend)
+ backend._supports_reasoning = flags["supports_reasoning"]
+ backend._reasoning_always_on = flags["reasoning_always_on"]
+ backend._reasoning_style = flags["reasoning_style"]
+ backend._reasoning_effort_levels = flags["reasoning_effort_levels"]
+ backend._supports_preserve_thinking = False
+ backend._architecture = None
+ return backend
+
+
+def _render(template, kwargs):
+ from jinja2.sandbox import ImmutableSandboxedEnvironment
+
+ def raise_exception(message):
+ raise ValueError(message)
+
+ env = ImmutableSandboxedEnvironment()
+ env.globals["raise_exception"] = raise_exception
+ return env.from_string(template).render(**(kwargs or {})).strip()
+
+
+def test_early_qwen38_ladder_is_detected_without_high():
+ backend = _backend(QWEN38_EARLY_TEMPLATE)
+ assert backend._reasoning_style == "enable_thinking_effort"
+ assert backend._reasoning_effort_levels == ["low", "medium", "xhigh"]
+
+
+ ("requested", "rendered"),
+ [
+ ("minimal", "low"),
+ ("low", "low"),
+ ("medium", "medium"),
+ ("high", "medium"),
+ ("xhigh", "xhigh"),
+ ("max", "xhigh"),
+ ],
+)
+def test_every_request_renders_the_nearest_offered_level(requested, rendered):
+ backend = _backend(QWEN38_EARLY_TEMPLATE)
+ kwargs = backend._request_reasoning_kwargs(True, requested)
+ assert kwargs == {"enable_thinking": True, "reasoning_effort": rendered}
+ assert _render(QWEN38_EARLY_TEMPLATE, kwargs) == f"effort={rendered}"
+
+
+def test_an_effort_alone_still_turns_thinking_on():
+ backend = _backend(QWEN38_EARLY_TEMPLATE)
+ assert backend._request_reasoning_kwargs(None, "high") == {
+ "enable_thinking": True,
+ "reasoning_effort": "medium",
+ }
+
+
[email protected](("enable_thinking", "effort"), [(False, "high"), (None, "none")])
+def test_off_stays_off_without_an_effort(enable_thinking, effort):
+ backend = _backend(QWEN38_EARLY_TEMPLATE)
+ kwargs = backend._request_reasoning_kwargs(enable_thinking, effort)
+ assert kwargs == {"enable_thinking": False}
+ assert _render(QWEN38_EARLY_TEMPLATE, kwargs) == "effort=off"
+
+
+def test_no_effort_leaves_the_template_default():
+ backend = _backend(QWEN38_EARLY_TEMPLATE)
+ assert backend._request_reasoning_kwargs(True, None) == {"enable_thinking": True}
+ assert backend._request_reasoning_kwargs(None, None) is None
+
+
+ ("requested", "levels", "expected"),
+ [
+ # GLM-5.2: high is the weakest offered level.
+ ("low", ["high", "max"], "high"),
+ ("medium", ["high", "max"], "high"),
+ # Claude 4.6: xhigh aliases to max.
+ ("xhigh", ["low", "medium", "high", "max"], "max"),
+ # Kimi-K3.
+ ("medium", ["low", "high", "max"], "low"),
+ ("xhigh", ["low", "high", "max"], "max"),
+ # Nothing to clamp onto.
+ ("high", [], None),
+ (None, ["low", "high"], None),
+ ("turbo", ["low", "high"], None),
+ ],
+)
+def test_clamp_matches_the_think_menu(requested, levels, expected):
+ from core.inference.llama_cpp import _clamp_reasoning_effort_to_levels
+ assert _clamp_reasoning_effort_to_levels(requested, levels) == expected
+
+
+def test_substitution_is_logged_once_per_ladder(monkeypatch):
+ from core.inference import llama_cpp
+
+ backend = _backend(QWEN38_EARLY_TEMPLATE)
+ messages = []
+ monkeypatch.setattr(llama_cpp, "_REASONING_EFFORT_CLAMPS_LOGGED", set())
+ monkeypatch.setattr(llama_cpp.logger, "info", lambda message, *a, **k: messages.append(message))
+ for _ in range(3):
+ backend._request_reasoning_kwargs(True, "high")
+ backend._request_reasoning_kwargs(True, "medium")
+
+ assert messages == [
+ "reasoning_effort 'high' is not offered by this template "
+ "['low', 'medium', 'xhigh']; using 'medium'"
+ ]