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: 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.pyindex 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"] = effortelif 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.pynew file mode 100644index 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'"+ ]