Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)
Python
Add per-model thinking toggles
Alishahryar11f12a33dd7ce
diff --git a/.env.example b/.env.exampleindex 77fef510..93794ac9 100644--- a/.env.example+++ b/.env.example@@ -28,9 +28,12 @@ MODEL="nvidia_nim/z-ai/glm4.7"# Thinking output-# Global switch for provider reasoning requests and Claude thinking blocks.-# Set false to suppress thinking across NIM, OpenRouter, LM Studio, and llama.cpp.-ENABLE_THINKING=true+# Per-Claude-model-family switches for provider reasoning requests and Claude thinking blocks.+# MODEL_ENABLE_THINKING applies when the incoming Claude model is not Opus, Sonnet, or Haiku.+OPUS_ENABLE_THINKING=true+SONNET_ENABLE_THINKING=true+HAIKU_ENABLE_THINKING=true+MODEL_ENABLE_THINKING=true# Provider configdiff --git a/README.md b/README.mdindex 6a2e11da..2cff1524 100644--- a/README.md+++ b/README.md@@ -81,8 +81,11 @@ MODEL_SONNET="nvidia_nim/moonshotai/kimi-k2-thinking"MODEL_HAIKU="nvidia_nim/stepfun-ai/step-3.5-flash"MODEL="nvidia_nim/z-ai/glm4.7" # fallback-# Global switch for provider reasoning requests and Claude thinking blocks.-ENABLE_THINKING=true+# Per-Claude-model-family switches for provider reasoning requests and Claude thinking blocks.+OPUS_ENABLE_THINKING=true+SONNET_ENABLE_THINKING=true+HAIKU_ENABLE_THINKING=true+MODEL_ENABLE_THINKING=true```</details>@@ -158,7 +161,7 @@ MODEL="nvidia_nim/z-ai/glm4.7" # fallback</details>-> Migration: `NIM_ENABLE_THINKING` was removed in this release. Rename it to `ENABLE_THINKING`.+> Migration: `NIM_ENABLE_THINKING` and `ENABLE_THINKING` were removed in this release. Use `MODEL_ENABLE_THINKING` for fallback behavior, or `OPUS_ENABLE_THINKING`, `SONNET_ENABLE_THINKING`, and `HAIKU_ENABLE_THINKING` for family-specific control.<details><summary><b>Optional Authentication</b> (restrict access to your proxy)</summary>@@ -321,7 +324,7 @@ free-claude-code # starts the server- **Per-model routing**: Opus / Sonnet / Haiku requests resolve to their model-specific backend, with `MODEL` as fallback- **Request optimization**: 5 categories of trivial requests (quota probes, title generation, prefix detection, suggestions, filepath extraction) are intercepted and responded to locally without using API quota- **Format translation**: Requests are translated from Anthropic format to the provider's OpenAI-compatible format and streamed back-- **Thinking tokens**: `<think>` tags and `reasoning_content` fields are converted into native Claude thinking blocks when `ENABLE_THINKING=true`+- **Thinking tokens**: `<think>` tags and `reasoning_content` fields are converted into native Claude thinking blocks when the matching `*_ENABLE_THINKING` flag is trueThe proxy also exposes Claude-compatible probe routes: `GET /v1/models`, `POST /v1/messages`, `POST /v1/messages/count_tokens`, plus `HEAD`/`OPTIONS` support for the common probe endpoints.@@ -507,7 +510,10 @@ Configure via `WHISPER_DEVICE` (`cpu` | `cuda` | `nvidia_nim`) and `WHISPER_MODE| `MODEL_SONNET` | Model for Claude Sonnet requests (falls back to `MODEL`) | `open_router/arcee-ai/trinity-large-preview:free` || `MODEL_HAIKU` | Model for Claude Haiku requests (falls back to `MODEL`) | `open_router/stepfun/step-3.5-flash:free` || `NVIDIA_NIM_API_KEY` | NVIDIA API key | required for NIM |-| `ENABLE_THINKING` | Global switch for provider reasoning requests and Claude thinking blocks. Set `false` to hide thinking across all providers. | `true` |+| `OPUS_ENABLE_THINKING` | Thinking switch for Claude Opus requests | `true` |+| `SONNET_ENABLE_THINKING` | Thinking switch for Claude Sonnet requests | `true` |+| `HAIKU_ENABLE_THINKING` | Thinking switch for Claude Haiku requests | `true` |+| `MODEL_ENABLE_THINKING` | Thinking switch for unrecognized Claude model names and fallback `MODEL` requests | `true` || `OPENROUTER_API_KEY` | OpenRouter API key | required for OpenRouter || `DEEPSEEK_API_KEY` | DeepSeek API key | required for DeepSeek || `LM_STUDIO_BASE_URL` | LM Studio server URL | `http://localhost:1234/v1` |diff --git a/api/dependencies.py b/api/dependencies.pyindex dfd30c7b..bb777929 100644--- a/api/dependencies.py+++ b/api/dependencies.py@@ -29,6 +29,22 @@ def _get_proxy_value(settings: Settings, attr_name: str) -> str:return value if isinstance(value, str) else ""+def _provider_config_kwargs(settings: Settings) -> dict:+ """Return settings shared by all provider configs."""+ return {+ "rate_limit": settings.provider_rate_limit,+ "rate_window": settings.provider_rate_window,+ "max_concurrency": settings.provider_max_concurrency,+ "http_read_timeout": settings.http_read_timeout,+ "http_write_timeout": settings.http_write_timeout,+ "http_connect_timeout": settings.http_connect_timeout,+ "opus_enable_thinking": settings.opus_enable_thinking,+ "sonnet_enable_thinking": settings.sonnet_enable_thinking,+ "haiku_enable_thinking": settings.haiku_enable_thinking,+ "model_enable_thinking": settings.model_enable_thinking,+ }++def _create_provider_for_type(provider_type: str, settings: Settings) -> BaseProvider:"""Construct and return a new provider instance for the given provider type."""_proxy_map = {@@ -48,14 +64,8 @@ def _create_provider_for_type(provider_type: str, settings: Settings) -> BaseProconfig = ProviderConfig(api_key=settings.nvidia_nim_api_key,base_url=NVIDIA_NIM_BASE_URL,- rate_limit=settings.provider_rate_limit,- rate_window=settings.provider_rate_window,- max_concurrency=settings.provider_max_concurrency,- http_read_timeout=settings.http_read_timeout,- http_write_timeout=settings.http_write_timeout,- http_connect_timeout=settings.http_connect_timeout,- enable_thinking=settings.enable_thinking,proxy=proxy,+ **_provider_config_kwargs(settings),)return NvidiaNimProvider(config, nim_settings=settings.nim)if provider_type == "open_router":@@ -67,14 +77,8 @@ def _create_provider_for_type(provider_type: str, settings: Settings) -> BaseProconfig = ProviderConfig(api_key=settings.open_router_api_key,base_url=OPENROUTER_BASE_URL,- rate_limit=settings.provider_rate_limit,- rate_window=settings.provider_rate_window,- max_concurrency=settings.provider_max_concurrency,- http_read_timeout=settings.http_read_timeout,- http_write_timeout=settings.http_write_timeout,- http_connect_timeout=settings.http_connect_timeout,- enable_thinking=settings.enable_thinking,proxy=proxy,+ **_provider_config_kwargs(settings),)return OpenRouterProvider(config)if provider_type == "deepseek":@@ -86,41 +90,23 @@ def _create_provider_for_type(provider_type: str, settings: Settings) -> BaseProconfig = ProviderConfig(api_key=settings.deepseek_api_key,base_url=DEEPSEEK_BASE_URL,- rate_limit=settings.provider_rate_limit,- rate_window=settings.provider_rate_window,- max_concurrency=settings.provider_max_concurrency,- http_read_timeout=settings.http_read_timeout,- http_write_timeout=settings.http_write_timeout,- http_connect_timeout=settings.http_connect_timeout,- enable_thinking=settings.enable_thinking,+ **_provider_config_kwargs(settings),)return DeepSeekProvider(config)if provider_type == "lmstudio":config = ProviderConfig(api_key="lm-studio",base_url=settings.lm_studio_base_url,- rate_limit=settings.provider_rate_limit,- rate_window=settings.provider_rate_window,- max_concurrency=settings.provider_max_concurrency,- http_read_timeout=settings.http_read_timeout,- http_write_timeout=settings.http_write_timeout,- http_connect_timeout=settings.http_connect_timeout,- enable_thinking=settings.enable_thinking,proxy=proxy,+ **_provider_config_kwargs(settings),)return LMStudioProvider(config)if provider_type == "llamacpp":config = ProviderConfig(api_key="llamacpp",base_url=settings.llamacpp_base_url,- rate_limit=settings.provider_rate_limit,- rate_window=settings.provider_rate_window,- max_concurrency=settings.provider_max_concurrency,- http_read_timeout=settings.http_read_timeout,- http_write_timeout=settings.http_write_timeout,- http_connect_timeout=settings.http_connect_timeout,- enable_thinking=settings.enable_thinking,proxy=proxy,+ **_provider_config_kwargs(settings),)return LlamaCppProvider(config)logger.error(diff --git a/config/settings.py b/config/settings.pyindex e15e35d1..5544c88a 100644--- a/config/settings.py+++ b/config/settings.py@@ -56,21 +56,29 @@ def _env_file_contains_key(path: Path, key: str) -> bool:def _removed_env_var_message(model_config: Mapping[str, Any]) -> str | None:"""Return a migration error for removed env vars, if present."""- removed_key = "NIM_ENABLE_THINKING"- replacement = "ENABLE_THINKING"-- if removed_key in os.environ:- return (- f"{removed_key} has been removed in this release. "- f"Rename it to {replacement}."- )-- for env_file in _configured_env_files(model_config):- if _env_file_contains_key(env_file, removed_key):- return (- f"{removed_key} has been removed in this release. "- f"Rename it to {replacement}. Found in {env_file}."- )+ removed_vars = {+ "NIM_ENABLE_THINKING": (+ "Use MODEL_ENABLE_THINKING for fallback behavior, or "+ "OPUS_ENABLE_THINKING, SONNET_ENABLE_THINKING, and "+ "HAIKU_ENABLE_THINKING for family-specific control."+ ),+ "ENABLE_THINKING": (+ "Rename it to MODEL_ENABLE_THINKING for fallback behavior, or "+ "use OPUS_ENABLE_THINKING, SONNET_ENABLE_THINKING, and "+ "HAIKU_ENABLE_THINKING for family-specific control."+ ),+ }++ for removed_key, replacement in removed_vars.items():+ if removed_key in os.environ:+ return f"{removed_key} has been removed in this release. {replacement}"++ for env_file in _configured_env_files(model_config):+ if _env_file_contains_key(env_file, removed_key):+ return (+ f"{removed_key} has been removed in this release. "+ f"{replacement} Found in {env_file}."+ )return None@@ -130,7 +138,18 @@ class Settings(BaseSettings):provider_max_concurrency: int = Field(default=5, validation_alias="PROVIDER_MAX_CONCURRENCY")- enable_thinking: bool = Field(default=True, validation_alias="ENABLE_THINKING")+ opus_enable_thinking: bool = Field(+ default=True, validation_alias="OPUS_ENABLE_THINKING"+ )+ sonnet_enable_thinking: bool = Field(+ default=True, validation_alias="SONNET_ENABLE_THINKING"+ )+ haiku_enable_thinking: bool = Field(+ default=True, validation_alias="HAIKU_ENABLE_THINKING"+ )+ model_enable_thinking: bool = Field(+ default=True, validation_alias="MODEL_ENABLE_THINKING"+ )# ==================== HTTP Client Timeouts ====================http_read_timeout: float = Field(@@ -287,6 +306,17 @@ class Settings(BaseSettings):return self.model_sonnetreturn self.model+ def resolve_thinking_enabled(self, claude_model_name: str) -> bool:+ """Resolve the configured thinking flag for a Claude model family."""+ name_lower = claude_model_name.lower()+ if "opus" in name_lower:+ return self.opus_enable_thinking+ if "haiku" in name_lower:+ return self.haiku_enable_thinking+ if "sonnet" in name_lower:+ return self.sonnet_enable_thinking+ return self.model_enable_thinking+@staticmethoddef parse_provider_type(model_string: str) -> str:"""Extract provider type from any 'provider/model' string."""diff --git a/providers/base.py b/providers/base.pyindex ecf02e16..c95f0285 100644--- a/providers/base.py+++ b/providers/base.py@@ -22,7 +22,10 @@ class ProviderConfig(BaseModel):http_read_timeout: float = 300.0http_write_timeout: float = 10.0http_connect_timeout: float = 2.0- enable_thinking: bool = True+ opus_enable_thinking: bool = True+ sonnet_enable_thinking: bool = True+ haiku_enable_thinking: bool = True+ model_enable_thinking: bool = Trueproxy: str = ""@@ -40,7 +43,22 @@ class BaseProvider(ABC):if thinking is not None and hasattr(thinking, "enabled")else True)- return self._config.enable_thinking and request_enabled+ request_model = getattr(request, "original_model", None) or getattr(+ request, "model", ""+ )+ model_enabled = self._resolve_model_thinking_enabled(str(request_model))+ return model_enabled and request_enabled++ def _resolve_model_thinking_enabled(self, model: str) -> bool:+ """Return the configured thinking flag for a Claude model family."""+ model_lower = model.lower()+ if "opus" in model_lower:+ return self._config.opus_enable_thinking+ if "haiku" in model_lower:+ return self._config.haiku_enable_thinking+ if "sonnet" in model_lower:+ return self._config.sonnet_enable_thinking+ return self._config.model_enable_thinking@abstractmethodasync def cleanup(self) -> None:diff --git a/tests/api/test_dependencies.py b/tests/api/test_dependencies.pyindex 892373af..97f906db 100644--- a/tests/api/test_dependencies.py+++ b/tests/api/test_dependencies.py@@ -32,7 +32,10 @@ def _make_mock_settings(**overrides):mock.http_read_timeout = 300.0mock.http_write_timeout = 10.0mock.http_connect_timeout = 2.0- mock.enable_thinking = True+ mock.opus_enable_thinking = True+ mock.sonnet_enable_thinking = True+ mock.haiku_enable_thinking = True+ mock.model_enable_thinking = Truefor key, value in overrides.items():setattr(mock, key, value)return mock@@ -134,7 +137,7 @@ async def test_get_provider_deepseek():assert isinstance(provider, DeepSeekProvider)assert provider._base_url == "https://api.deepseek.com"assert provider._api_key == "test_deepseek_key"- assert provider._config.enable_thinking is True+ assert provider._config.model_enable_thinking is True@pytest.mark.asyncio@@ -152,18 +155,38 @@ async def test_get_provider_deepseek_uses_fixed_base_url():@pytest.mark.asyncio-async def test_get_provider_deepseek_passes_enable_thinking():- """DeepSeek provider receives the global thinking toggle."""+async def test_get_provider_deepseek_passes_model_enable_thinking():+ """DeepSeek provider receives the fallback thinking toggle."""with patch("api.dependencies.get_settings") as mock_settings:mock_settings.return_value = _make_mock_settings(provider_type="deepseek",- enable_thinking=False,+ model_enable_thinking=False,)provider = get_provider()assert isinstance(provider, DeepSeekProvider)- assert provider._config.enable_thinking is False+ assert provider._config.model_enable_thinking is False+++async def test_get_provider_passes_per_model_thinking_flags():+ """Provider config receives every per-model thinking toggle."""+ with patch("api.dependencies.get_settings") as mock_settings:+ mock_settings.return_value = _make_mock_settings(+ opus_enable_thinking=False,+ sonnet_enable_thinking=True,+ haiku_enable_thinking=False,+ model_enable_thinking=True,+ )++ provider = get_provider()++ assert isinstance(provider, NvidiaNimProvider)+ assert provider._config.opus_enable_thinking is False+ assert provider._config.sonnet_enable_thinking is True+ assert provider._config.haiku_enable_thinking is False+ assert provider._config.model_enable_thinking is True@pytest.mark.asynciodiff --git a/tests/config/test_config.py b/tests/config/test_config.pyindex d08031a9..8e9ac8c0 100644--- a/tests/config/test_config.py+++ b/tests/config/test_config.py@@ -29,7 +29,10 @@ class TestSettings:assert isinstance(settings.provider_rate_window, int)assert isinstance(settings.nim.temperature, float)assert isinstance(settings.fast_prefix_detection, bool)- assert isinstance(settings.enable_thinking, bool)+ assert isinstance(settings.opus_enable_thinking, bool)+ assert isinstance(settings.sonnet_enable_thinking, bool)+ assert isinstance(settings.haiku_enable_thinking, bool)+ assert isinstance(settings.model_enable_thinking, bool)assert settings.http_read_timeout == 120.0def test_get_settings_cached(self):@@ -110,20 +113,34 @@ class TestSettings:settings = Settings()assert settings.http_connect_timeout == 5.0- def test_enable_thinking_from_env(self, monkeypatch):- """ENABLE_THINKING env var is loaded into settings."""+ def test_per_model_thinking_from_env(self, monkeypatch):+ """Per-model thinking env vars are loaded into settings."""from config.settings import Settings- monkeypatch.setenv("ENABLE_THINKING", "false")+ monkeypatch.setenv("OPUS_ENABLE_THINKING", "false")+ monkeypatch.setenv("SONNET_ENABLE_THINKING", "true")+ monkeypatch.setenv("HAIKU_ENABLE_THINKING", "false")+ monkeypatch.setenv("MODEL_ENABLE_THINKING", "true")settings = Settings()- assert settings.enable_thinking is False+ assert settings.opus_enable_thinking is False+ assert settings.sonnet_enable_thinking is True+ assert settings.haiku_enable_thinking is False+ assert settings.model_enable_thinking is Truedef test_removed_nim_enable_thinking_raises(self, monkeypatch):"""NIM_ENABLE_THINKING now fails fast with a migration message."""from config.settings import Settingsmonkeypatch.setenv("NIM_ENABLE_THINKING", "false")- with pytest.raises(ValidationError, match="Rename it to ENABLE_THINKING"):+ with pytest.raises(ValidationError, match="MODEL_ENABLE_THINKING"):+ Settings()++ def test_removed_enable_thinking_raises(self, monkeypatch):+ """ENABLE_THINKING now fails fast with a migration message."""+ from config.settings import Settings++ monkeypatch.setenv("ENABLE_THINKING", "false")+ with pytest.raises(ValidationError, match="MODEL_ENABLE_THINKING"):Settings()@@ -494,6 +511,29 @@ class TestPerModelMapping:s.model_opus = "open_router/opus-model"assert s.resolve_model("Claude-OPUS-4") == "open_router/opus-model"+ def test_resolve_thinking_enabled_per_model_family(self):+ """resolve_thinking_enabled returns the matching model-family flag."""+ from config.settings import Settings++ s = Settings()+ s.opus_enable_thinking = False+ s.sonnet_enable_thinking = True+ s.haiku_enable_thinking = False+ s.model_enable_thinking = True++ assert s.resolve_thinking_enabled("claude-opus-4-20250514") is False+ assert s.resolve_thinking_enabled("claude-sonnet-4-20250514") is True+ assert s.resolve_thinking_enabled("claude-haiku-4-20250514") is False+ assert s.resolve_thinking_enabled("claude-2.1") is True++ def test_resolve_thinking_enabled_case_insensitive(self):+ """Thinking model-family classification is case-insensitive."""+ from config.settings import Settings++ s = Settings()+ s.opus_enable_thinking = False+ assert s.resolve_thinking_enabled("Claude-OPUS-4") is False+def test_parse_provider_type(self):"""parse_provider_type extracts provider from model string."""from config.settings import Settingsdiff --git a/tests/providers/test_base.py b/tests/providers/test_base.pynew file mode 100644index 00000000..bfc0d2c6--- /dev/null+++ b/tests/providers/test_base.py@@ -0,0 +1,78 @@+from providers.base import BaseProvider, ProviderConfig+++class DummyProvider(BaseProvider):+ async def cleanup(self) -> None:+ return None++ async def stream_response(self, request, input_tokens=0, *, request_id=None):+ if False:+ yield ""+++class DummyThinking:+ def __init__(self, enabled: bool):+ self.enabled = enabled+++class DummyRequest:+ def __init__(+ self,+ *,+ model: str,+ original_model: str | None = None,+ thinking: DummyThinking | None = None,+ ):+ self.model = model+ self.original_model = original_model+ self.thinking = thinking+++def test_is_thinking_enabled_uses_original_model_family():+ provider = DummyProvider(+ ProviderConfig(+ api_key="test",+ opus_enable_thinking=False,+ model_enable_thinking=True,+ )+ )+ request = DummyRequest(+ model="provider-model",+ original_model="claude-opus-4-20250514",+ thinking=DummyThinking(True),+ )++ assert provider._is_thinking_enabled(request) is False+++def test_is_thinking_enabled_falls_back_to_request_model():+ provider = DummyProvider(+ ProviderConfig(+ api_key="test",+ sonnet_enable_thinking=False,+ model_enable_thinking=True,+ )+ )+ request = DummyRequest(model="claude-sonnet-4-20250514")++ assert provider._is_thinking_enabled(request) is False+++def test_is_thinking_enabled_unknown_model_uses_fallback_flag():+ provider = DummyProvider(+ ProviderConfig(api_key="test", model_enable_thinking=False)+ )+ request = DummyRequest(model="provider-model")++ assert provider._is_thinking_enabled(request) is False+++def test_is_thinking_enabled_respects_request_disable():+ provider = DummyProvider(ProviderConfig(api_key="test", opus_enable_thinking=True))+ request = DummyRequest(+ model="provider-model",+ original_model="claude-opus-4-20250514",+ thinking=DummyThinking(False),+ )++ assert provider._is_thinking_enabled(request) is Falsediff --git a/tests/providers/test_deepseek.py b/tests/providers/test_deepseek.pyindex 965494af..496d5a16 100644--- a/tests/providers/test_deepseek.py+++ b/tests/providers/test_deepseek.py@@ -44,7 +44,6 @@ def deepseek_config():base_url=DEEPSEEK_BASE_URL,rate_limit=10,rate_window=60,- enable_thinking=True,)@@ -86,15 +85,15 @@ def test_build_request_body_enables_thinking_for_chat_model(deepseek_provider):assert body["messages"][0]["role"] == "system"-def test_build_request_body_global_disable_blocks_request_thinking():- """Global disable suppresses provider-side thinking even if the request enables it."""+def test_build_request_body_model_disable_blocks_request_thinking():+ """Model disable suppresses provider-side thinking even if the request enables it."""provider = DeepSeekProvider(ProviderConfig(api_key="test_deepseek_key",base_url=DEEPSEEK_BASE_URL,rate_limit=10,rate_window=60,- enable_thinking=False,+ model_enable_thinking=False,))req = MockRequest(model="deepseek-chat")@@ -103,8 +102,8 @@ def test_build_request_body_global_disable_blocks_request_thinking():assert "extra_body" not in body or "thinking" not in body["extra_body"]-def test_build_request_body_request_disable_blocks_global_thinking(deepseek_provider):- """Request-level disable suppresses provider-side thinking when global is enabled."""+def test_build_request_body_request_disable_blocks_model_thinking(deepseek_provider):+ """Request-level disable suppresses provider-side thinking when model is enabled."""req = MockRequest(model="deepseek-chat")req.thinking.enabled = Falsebody = deepseek_provider._build_request_body(req)diff --git a/tests/providers/test_llamacpp.py b/tests/providers/test_llamacpp.pyindex e1a9f05b..ead84b18 100644--- a/tests/providers/test_llamacpp.py+++ b/tests/providers/test_llamacpp.py@@ -111,9 +111,9 @@ def test_init_base_url_strips_trailing_slash():@pytest.mark.asyncio-async def test_stream_response_omits_thinking_when_globally_disabled(llamacpp_config):+async def test_stream_response_omits_thinking_when_model_disabled(llamacpp_config):provider = LlamaCppProvider(- llamacpp_config.model_copy(update={"enable_thinking": False})+ llamacpp_config.model_copy(update={"model_enable_thinking": False}))req = MockRequest()diff --git a/tests/providers/test_lmstudio.py b/tests/providers/test_lmstudio.pyindex 1173846c..3b67b7c5 100644--- a/tests/providers/test_lmstudio.py+++ b/tests/providers/test_lmstudio.py@@ -111,9 +111,9 @@ def test_init_base_url_strips_trailing_slash():@pytest.mark.asyncio-async def test_stream_response_omits_thinking_when_globally_disabled(lmstudio_config):+async def test_stream_response_omits_thinking_when_model_disabled(lmstudio_config):provider = LMStudioProvider(- lmstudio_config.model_copy(update={"enable_thinking": False})+ lmstudio_config.model_copy(update={"model_enable_thinking": False}))req = MockRequest()diff --git a/tests/providers/test_nvidia_nim.py b/tests/providers/test_nvidia_nim.pyindex 41d1e38d..6aaa8256 100644--- a/tests/providers/test_nvidia_nim.py+++ b/tests/providers/test_nvidia_nim.py@@ -121,13 +121,13 @@ async def test_build_request_body(provider_config):@pytest.mark.asyncio-async def test_build_request_body_omits_reasoning_when_globally_disabled(+async def test_build_request_body_omits_reasoning_when_model_disabled(provider_config,):from config.nim import NimSettingsprovider = NvidiaNimProvider(- provider_config.model_copy(update={"enable_thinking": False}),+ provider_config.model_copy(update={"model_enable_thinking": False}),nim_settings=NimSettings(),)req = MockRequest()@@ -244,7 +244,7 @@ async def test_stream_response_suppresses_thinking_when_disabled(provider_configfrom config.nim import NimSettingsprovider = NvidiaNimProvider(- provider_config.model_copy(update={"enable_thinking": False}),+ provider_config.model_copy(update={"model_enable_thinking": False}),nim_settings=NimSettings(),)req = MockRequest()diff --git a/tests/providers/test_open_router.py b/tests/providers/test_open_router.pyindex fbcfd475..adc2a62a 100644--- a/tests/providers/test_open_router.py+++ b/tests/providers/test_open_router.py@@ -105,9 +105,9 @@ def test_build_request_body_has_reasoning_extra(open_router_provider):assert body["extra_body"]["reasoning"]["enabled"] is True-def test_build_request_body_omits_reasoning_when_globally_disabled(open_router_config):+def test_build_request_body_omits_reasoning_when_model_disabled(open_router_config):provider = OpenRouterProvider(- open_router_config.model_copy(update={"enable_thinking": False})+ open_router_config.model_copy(update={"model_enable_thinking": False}))req = MockRequest()body = provider._build_request_body(req)@@ -228,7 +228,7 @@ async def test_stream_response_reasoning_content(open_router_provider):@pytest.mark.asyncioasync def test_stream_response_suppresses_reasoning_when_disabled(open_router_config):provider = OpenRouterProvider(- open_router_config.model_copy(update={"enable_thinking": False})+ open_router_config.model_copy(update={"model_enable_thinking": False}))req = MockRequest()diff --git a/tests/providers/test_streaming_errors.py b/tests/providers/test_streaming_errors.pyindex 04e9ee9a..f6ab2694 100644--- a/tests/providers/test_streaming_errors.py+++ b/tests/providers/test_streaming_errors.py@@ -46,7 +46,7 @@ def _make_provider_with_thinking_enabled(enabled: bool):base_url="https://test.api.nvidia.com/v1",rate_limit=10,rate_window=60,- enable_thinking=enabled,+ model_enable_thinking=enabled,)return NvidiaNimProvider(config, nim_settings=NimSettings())