fix: honor null reasoning effort disable

Author: boogieLing

nanobot/config/schema.py

@@ -103,6 +103,20 @@ class AgentDefaults(Base):
     )  # Consolidation target ratio (0.5 = 50% of budget retained after compression)
     dream: DreamConfig = Field(default_factory=DreamConfig)
 
+    def effective_reasoning_effort(self) -> str | None:
+        """Return the provider-facing reasoning setting.
+
+        An omitted field preserves provider defaults. An explicit JSON/YAML null
+        means "turn reasoning off", represented internally by the existing
+        ``"none"`` semantic so downstream code can distinguish it from omitted.
+        """
+        if (
+            self.reasoning_effort is None
+            and "reasoning_effort" in self.model_fields_set
+        ):
+            return "none"
+        return self.reasoning_effort
+
 
 class AgentsConfig(Base):
     """Agent configuration."""

nanobot/providers/factory.py

@@ -87,7 +87,7 @@ def make_provider(config: Config) -> LLMProvider:
     provider.generation = GenerationSettings(
         temperature=defaults.temperature,
         max_tokens=defaults.max_tokens,
-        reasoning_effort=defaults.reasoning_effort,
+        reasoning_effort=defaults.effective_reasoning_effort(),
     )
     return provider
 
@@ -97,6 +97,7 @@ def provider_signature(config: Config) -> tuple[object, ...]:
     model = config.agents.defaults.model
     defaults = config.agents.defaults
     p = config.get_provider(model)
+    reasoning_effort = defaults.effective_reasoning_effort()
     return (
         model,
         defaults.provider,
@@ -109,7 +110,7 @@ def provider_signature(config: Config) -> tuple[object, ...]:
         getattr(p, "profile", None) if p else None,
         defaults.max_tokens,
         defaults.temperature,
-        defaults.reasoning_effort,
+        reasoning_effort,
         defaults.context_window_tokens,
     )
 

nanobot/providers/openai_compat_provider.py

@@ -60,6 +60,8 @@
     "kimi-k2.6",
     "k2.6-code-preview",
 })
+_NULL_REASONING_DISABLE_MARKERS = frozenset({"mimo", "xiaomi", "xiaomimimo"})
+_NULL_REASONING_DISABLE_PREFIXES = ("mimo-", "mimo_", "mimo.")
 _OPENAI_COMPAT_REQUEST_TIMEOUT_S = 120.0
 
 # Maps ProviderSpec.thinking_style → extra_body builder.
@@ -91,6 +93,29 @@ def _is_kimi_thinking_model(model_name: str) -> bool:
     return False
 
 
+def _model_looks_like_null_reasoning_route(model_name: str) -> bool:
+    """Return True for model ids that are known to disable reasoning via null.
+
+    Gateway models usually arrive as publisher/model slugs. Match whole path
+    parts or known MiMo prefixes instead of arbitrary substrings so unrelated
+    names like "mimosa-pro" do not receive Xiaomi-specific payloads.
+    """
+    parts = tuple(part for part in model_name.lower().replace(":", "/").split("/") if part)
+    for part in parts:
+        if part in _NULL_REASONING_DISABLE_MARKERS:
+            return True
+        if part.startswith(_NULL_REASONING_DISABLE_PREFIXES):
+            return True
+    return False
+
+
+def _needs_null_reasoning_disable(spec: ProviderSpec | None, model_name: str) -> bool:
+    """Return True for OpenAI-compatible routes that disable thinking via JSON null."""
+    if spec and spec.reasoning_disable_style == "reasoning_effort_null":
+        return True
+    return _model_looks_like_null_reasoning_route(model_name)
+
+
 def _openai_compat_timeout_s() -> float:
     """Return the bounded request timeout used for OpenAI-compatible providers."""
     return _float_env("NANOBOT_OPENAI_COMPAT_TIMEOUT_S", _OPENAI_COMPAT_REQUEST_TIMEOUT_S)
@@ -585,6 +610,12 @@ def _build_kwargs(
 
         if wire_effort and semantic_effort != "none":
             kwargs["reasoning_effort"] = wire_effort
+        elif semantic_effort == "none" and _needs_null_reasoning_disable(spec, model_name):
+            # Some OpenAI-compatible thinking models, notably Xiaomi MiMo
+            # directly and through routers, require an explicit JSON null to
+            # override the provider/model default. Put it in extra_body so the
+            # OpenAI SDK cannot treat a top-level None as an omitted argument.
+            kwargs.setdefault("extra_body", {})["reasoning_effort"] = None
 
         # Provider-specific thinking parameters.
         # Only sent when reasoning_effort is explicitly configured so that

nanobot/providers/registry.py

@@ -71,6 +71,12 @@ class ProviderSpec:
     # "reasoning_split" — {"reasoning_split": true/false}  (MiniMax)
     thinking_style: str = ""
 
+    # How to explicitly disable provider-default reasoning when
+    # reasoning_effort resolves to "none".
+    # "" — no provider-specific disable payload
+    # "reasoning_effort_null" — {"reasoning_effort": null} in extra_body
+    reasoning_disable_style: str = ""
+
     # When True, treat the "reasoning" response field as formal content
     # when "content" is empty.  Only set this for providers (e.g. StepFun)
     # whose API returns the actual answer in "reasoning" instead of "content".
@@ -375,6 +381,7 @@ def label(self) -> str:
         display_name="Xiaomi MIMO",
         backend="openai_compat",
         default_api_base="https://api.xiaomimimo.com/v1",
+        reasoning_disable_style="reasoning_effort_null",
     ),
     # LongCat: OpenAI-compatible API
     ProviderSpec(

tests/providers/test_litellm_kwargs.py

@@ -1134,6 +1134,40 @@ def test_dashscope_thinking_disabled_for_none_string() -> None:
     assert "reasoning_effort" not in kw
 
 
+def test_xiaomi_mimo_none_sends_explicit_null_disable() -> None:
+    """MiMo needs an explicit JSON null to override its thinking-on default."""
+    kw = _build_kwargs_for("xiaomi_mimo", "mimo-pro", reasoning_effort="none")
+    assert kw.get("extra_body") == {"reasoning_effort": None}
+    assert "reasoning_effort" not in kw
+
+
+def test_openrouter_mimo_none_sends_explicit_null_disable() -> None:
+    """OpenRouter MiMo routes also need the null disable signal passed through."""
+    kw = _build_kwargs_for("openrouter", "xiaomi/mimo-pro", reasoning_effort="none")
+    assert kw.get("extra_body") == {"reasoning_effort": None}
+    assert "reasoning_effort" not in kw
+
+
+def test_openrouter_non_mimo_none_preserves_provider_default() -> None:
+    kw = _build_kwargs_for("openrouter", "openai/gpt-4o", reasoning_effort="none")
+    assert "extra_body" not in kw
+    assert "reasoning_effort" not in kw
+
+
+def test_custom_mimo_none_sends_explicit_null_disable() -> None:
+    """Custom Xiaomi-compatible routes still get the MiMo disable signal by model id."""
+    kw = _build_kwargs_for("custom", "mimo-pro", reasoning_effort="none")
+    assert kw.get("extra_body") == {"reasoning_effort": None}
+    assert "reasoning_effort" not in kw
+
+
+def test_mimosa_model_name_does_not_match_mimo_defense() -> None:
+    """Avoid sending Xiaomi-specific null payloads for substring-only matches."""
+    kw = _build_kwargs_for("openrouter", "example/mimosa-pro", reasoning_effort="none")
+    assert "extra_body" not in kw
+    assert "reasoning_effort" not in kw
+
+
 def test_deepseek_no_backfill_when_reasoning_effort_none_string() -> None:
     """reasoning_effort='none' must NOT trigger reasoning_content backfill (thinking inactive)."""
     spec = find_by_name("deepseek")

tests/providers/test_provider_factory.py

@@ -0,0 +1,41 @@
+from unittest.mock import patch
+
+from nanobot.config.schema import Config
+from nanobot.providers.factory import make_provider, provider_signature
+
+
+def test_explicit_null_reasoning_effort_becomes_provider_disable_signal() -> None:
+    config = Config.model_validate({
+        "providers": {"xiaomiMimo": {"apiKey": "sk-test"}},
+        "agents": {
+            "defaults": {
+                "provider": "xiaomi_mimo",
+                "model": "mimo-pro",
+                "reasoningEffort": None,
+            }
+        },
+    })
+
+    with patch("nanobot.providers.openai_compat_provider.AsyncOpenAI"):
+        provider = make_provider(config)
+
+    assert provider.generation.reasoning_effort == "none"
+    assert provider_signature(config)[11] == "none"
+
+
+def test_omitted_reasoning_effort_preserves_provider_default() -> None:
+    config = Config.model_validate({
+        "providers": {"xiaomiMimo": {"apiKey": "sk-test"}},
+        "agents": {
+            "defaults": {
+                "provider": "xiaomi_mimo",
+                "model": "mimo-pro",
+            }
+        },
+    })
+
+    with patch("nanobot.providers.openai_compat_provider.AsyncOpenAI"):
+        provider = make_provider(config)
+
+    assert provider.generation.reasoning_effort is None
+    assert provider_signature(config)[11] is None