comments

Author: chenmoneygithub

dspy/adapters/types/reasoning.py

@@ -44,18 +44,19 @@ def adapt_to_native_lm_feature(cls, lm, lm_kwargs) -> bool:
         if not litellm.supports_reasoning(lm.model):
             return False
 
+        reasoning_effort = "unspecified"
         if "reasoning_effort" in lm_kwargs:
             # `lm_kwargs` overrides `lm.kwargs`
             reasoning_effort = lm_kwargs["reasoning_effort"]
         elif "reasoning_effort" in lm.kwargs:
             reasoning_effort = lm.kwargs["reasoning_effort"]
-        else:
-            reasoning_effort = None
 
         if reasoning_effort is None:
-            # Turn on the native reasoning
-            lm_kwargs["reasoning_effort"] = "low"
+            # If users explicitly set `reasoning_effort` to None, we don't enable native reasoning
+            return False
 
+        # Turn on the native reasoning
+        lm_kwargs["reasoning_effort"] = "low"
         return True
 
     @classmethod

dspy/clients/lm.py

@@ -103,15 +103,6 @@ def __init__(
 
         self._warn_zero_temp_rollout(self.kwargs.get("temperature"), self.kwargs.get("rollout_id"))
 
-        # Normalize reasoning_effort to get reasoning summaries (for OpenAI reasoning models which don't expose
-        # reasoning content)
-        if "reasoning_effort" in self.kwargs and (
-            self.model_type == "responses"
-            or ("openai/" in self.model.lower() and litellm.supports_reasoning(self.model))
-        ):
-            effort = self.kwargs.pop("reasoning_effort")
-            self.kwargs["reasoning"] = {"effort": effort, "summary": "auto"}
-
     def _warn_zero_temp_rollout(self, temperature: float | None, rollout_id):
         if not self._warned_zero_temp_rollout and rollout_id is not None and (temperature is None or temperature == 0):
             warnings.warn(
@@ -463,4 +454,8 @@ def _convert_chat_request_to_responses_request(request: dict[str, Any]):
             elif isinstance(c, list):
                 content_blocks.extend(c)
         request["input"] = [{"role": msg.get("role", "user"), "content": content_blocks}]
+    # Convert reasoning_effort to reasoning format supported by the Responses API
+    if "reasoning_effort" in request:
+        effort = request.pop("reasoning_effort")
+        request["reasoning"] = {"effort": effort, "summary": "auto"}
     return request

dspy/predict/chain_of_thought.py

@@ -1,10 +1,13 @@
+import logging
 from typing import Any
 
 import dspy
 from dspy.primitives.module import Module
 from dspy.signatures.field import OutputField
 from dspy.signatures.signature import Signature, ensure_signature
 
+logger = logging.getLogger(__name__)
+
 
 class ChainOfThought(Module):
     def __init__(
@@ -22,6 +25,9 @@ def __init__(
         super().__init__()
         signature = ensure_signature(signature)
 
+        if "rationale_field" in config or "rationale_field_type" in config:
+            logger.warning("`rationale_field` and `rationale_field_type` are deprecated, they are no-op now.")
+
         from dspy.adapters.types.reasoning import Reasoning
 
         extended_signature = signature.prepend(name="reasoning", field=OutputField(), type_=Reasoning)

tests/clients/test_lm.py

@@ -565,25 +565,17 @@ def test_responses_api_tool_calls(litellm_test_server):
         assert dspy_responses.call_args.kwargs["model"] == "openai/dspy-test-model"
 
 
-def test_reasoning_effort_normalization():
-    """Test that reasoning_effort gets normalized to reasoning format for OpenAI models."""
-    with mock.patch("litellm.supports_reasoning", return_value=True):
+def test_reasoning_effort_responses_api():
+    """Test that reasoning_effort gets normalized to reasoning format for Responses API."""
+    with mock.patch("litellm.responses") as mock_responses:
         # OpenAI model with Responses API - should normalize
-        lm1 = dspy.LM(
+        lm = dspy.LM(
             model="openai/gpt-5", model_type="responses", reasoning_effort="low", max_tokens=16000, temperature=1.0
         )
-        assert "reasoning_effort" not in lm1.kwargs
-        assert lm1.kwargs["reasoning"] == {"effort": "low", "summary": "auto"}
-
-        # OpenAI model with Chat API - should normalize
-        lm2 = dspy.LM(model="openai/gpt-5", reasoning_effort="medium", max_tokens=16000, temperature=1.0)
-        assert "reasoning_effort" not in lm2.kwargs
-        assert lm2.kwargs["reasoning"] == {"effort": "medium", "summary": "auto"}
-
-        # Non-OpenAI model - should NOT normalize
-        lm3 = dspy.LM(model="deepseek-ai/DeepSeek-R1", reasoning_effort="low", max_tokens=4000, temperature=0.7)
-        assert "reasoning_effort" in lm3.kwargs
-        assert "reasoning" not in lm3.kwargs
+        lm("openai query")
+        call_kwargs = mock_responses.call_args.kwargs
+        assert "reasoning_effort" not in call_kwargs
+        assert call_kwargs["reasoning"] == {"effort": "low", "summary": "auto"}
 
 
 def test_reasoning_content_extraction():