fix(llm): local Ollama provider falls back to no-think when model lacks thinking support

proteus/providers/ollama_local.py

@@ -19,6 +19,7 @@ import os
 
 import httpx
 
+from proteus.providers.base import CompletionResult
 from proteus.providers.ollama_cloud import OllamaCloudProvider
 
 logger = logging.getLogger(__name__)
@@ -87,3 +88,31 @@ class OllamaLocalProvider(OllamaCloudProvider):
             "OllamaLocalProvider targeting %s at %s (thinking=%s, effort=%s)",
             model, self._base_url, enable_thinking, reasoning_effort,
         )
+
+    def complete(
+        self,
+        messages: list[dict[str, str]],
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+    ) -> CompletionResult:
+        """Same native ``/api/chat`` call as the cloud parent, but tolerant of
+        models that don't support the ``think`` field.
+
+        ``reasoning_effort`` defaults to ``"low"`` for gpt-oss; a non-reasoning
+        local model (e.g. plain qwen/llama) answers Ollama's ``think`` with a
+        ``400 ... does not support thinking``. On that specific error we disable
+        ``think`` for the rest of this provider's life and retry once, so the
+        same toggle works across reasoning and non-reasoning local models.
+        """
+        try:
+            return super().complete(messages, temperature, max_tokens)
+        except httpx.HTTPStatusError as exc:
+            resp = exc.response
+            sent_think = self._reasoning_effort is not None or self._enable_thinking is not None
+            if (resp is not None and resp.status_code == 400 and sent_think
+                    and "thinking" in (resp.text or "").lower()):
+                logger.info("model %r does not support thinking; disabling and retrying", self._model)
+                self._reasoning_effort = None
+                self._enable_thinking = None
+                return super().complete(messages, temperature, max_tokens)
+            raise

tests/providers/test_ollama_local.py

@@ -50,6 +50,31 @@ def test_complete_sends_native_payload_no_auth_and_parses_thinking():
     assert res.input_tokens == 11 and res.output_tokens == 7
 
 
+def test_think_fallback_when_model_does_not_support_thinking():
+    # gpt-oss accepts think="low"; a plain (non-reasoning) local model returns a
+    # 400 "does not support thinking". The provider must drop think and retry.
+    calls = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        import json
+        body = json.loads(request.content)
+        calls.append(body)
+        if "think" in body:
+            return httpx.Response(400, json={"error": '"qwen" does not support thinking'})
+        return httpx.Response(200, json={
+            "message": {"content": "ACTION: stay"}, "prompt_eval_count": 3, "eval_count": 2,
+        })
+
+    p = _provider_with_mock(handler, model="qwen2.5:0.5b")   # reasoning_effort defaults to "low"
+    res = p.complete([{"role": "user", "content": "move"}])
+    assert "ACTION: stay" in res.text
+    assert len(calls) == 2                                    # first with think (400), retry without
+    assert "think" in calls[0] and "think" not in calls[1]
+    # think stays disabled for subsequent calls (no repeated 400 round-trip)
+    p.complete([{"role": "user", "content": "again"}])
+    assert "think" not in calls[2]
+
+
 def test_vanilla_agent_plays_a_move_via_local_provider():
     # End-to-end: the LLM-play agent parses a valid action from a gpt-oss-style reply.
     from proteus.game.agents.vanilla import VanillaAgent