[Bug]: reasoning_effort on Responses API models always adds reasoning.summary, causing 400s for unverified orgs

[Chesars]

Summary

When using reasoning_effort with models that have mode: "responses" in LiteLLM, the parameter is automatically converted to include
reasoning.summary. This causes 400 errors for OpenAI users with unverified organizations, since only reasoning.summary requires verification.

Current

In litellm/completion_extras/litellm_responses_transformation/transformation.py (lines 541-551):

def _map_reasoning_effort(self, reasoning_effort: str) -> Optional[Reasoning]:
    if reasoning_effort == "high":
        return Reasoning(effort="high", summary="detailed")  # ← Always adds summary
    elif reasoning_effort == "medium":
        return Reasoning(effort="medium", summary="auto")    # ← Always adds summary
    elif reasoning_effort == "low":
        return Reasoning(effort="low", summary="auto")        # ← Always adds summary
    elif reasoning_effort == "minimal":
        return Reasoning(effort="minimal", summary="auto")    # ← Always adds summary
    return None

OpenAI's official recommendations:

• reasoning.summary should be opt-in, not automatically added
• Source: OpenAI Reasoning Best Practices

Error Message

  {
    "error": {
      "message": "Your organization must be verified to generate reasoning summaries.
                  Please go to: https://platform.openai.com/settings/organization/general
                  and click on Verify Organization.",
      "type": "invalid_request_error",
      "param": "reasoning.summary",
      "code": "unsupported_value"
    }
  }

Why This Matters

1. reasoning.summary is optional - It's only for debugging/auditing the reasoning process, not required for model functionality
2. Not all users are verified - Many individual developers don't have (or need) verified organizations
3. reasoning_effort is useful alone - Users want to control reasoning computation without needing summaries
4. No workaround exists - Users can't use reasoning_effort at all if their org isn't verified

Proposed Solutions

Option 1: Make summary parameter optional (Recommended)

Allow users to control whether summary is included:

  def _map_reasoning_effort(
      self,
      reasoning_effort: str,
      include_summary: bool = False  # ← New parameter, defaults to False
  ) -> Optional[Reasoning]:
      if reasoning_effort == "high":
          summary = "detailed" if include_summary else None
          return Reasoning(effort="high", summary=summary)
      elif reasoning_effort == "medium":
          summary = "auto" if include_summary else None
          return Reasoning(effort="medium", summary=summary)
      # ... etc

Usage:
Without summary (works for unverified orgs)

completion(
     model="gpt-5-codex",
     messages=[...],
     reasoning_effort="high"  # No summary added
 )

With summary (requires verified org)

completion(
     model="gpt-5-codex",
     messages=[...],
     reasoning_effort="high",
     include_reasoning_summary=True  # Explicitly opt-in
 )

Option 2: Add separate reasoning_summary parameter

  completion(
      model="gpt-5-codex",
      messages=[...],
      reasoning_effort="high",       
      reasoning_summary="detailed"    # Optional 
  )

Recommendation

Option 1 is because:

• ✅ Backward compatible (defaults to False)
• ✅ Explicit opt-in (follows best practices)
• ✅ Clear API design

Related

• [Bug]: Default reasoning_effort='high' causes 400 errors with OpenAI Responses API models for unverified organizations OpenHands/OpenHands#11552
• Affects projects using LiteLLM with Responses API models
• OpenAI docs: https://platform.openai.com/docs/guides/reasoning

Relevant log output

Are you a ML Ops Team?

No

What LiteLLM version are you on ?

v1.77.7

Twitter / LinkedIn details

No response

[jasonpnnl]

This breaks using the completions API to Responses API bridge with OpenWebUI as there is no longer a way to get reasoning summaries.

Instead of disabling or enabling it globally, having it controlled by env var like LITELLM_REASONING_AUTO_SUMMARY could allow both scenarios to function.

[Chesars]

Hi @jasonpnnl!

The reasoning summary feature is still fully available - it's opt-in (as per OpenAI's documentation).

You can get reasoning summaries by passing reasoning_effort as a dictionary:

With summary (for verified organizations):

response = litellm.completion(
    model="openai/responses/gpt-5-mini",
    messages=[{"role": "user", "content": "Explain quantum computing"}],
    reasoning_effort={"effort": "high", "summary": "detailed"}  # or "auto"
)

 #  Without summary:
  response = litellm.completion(
      model="openai/responses/gpt-5-mini",
      messages=[{"role": "user", "content": "Explain quantum computing"}],
      reasoning_effort="high"  # String format - no summary
  )

[jasonpnnl]

Unfortunately, this is not a viable solution when using OpenWebUI as-is because the summary included as part of the reasoning_effort dictionary is not supported. I believe this is because in the completions API, summary is not a valid parameter. Summary included in the reasoning_effort dict is only supported in the responses API.

I made my own modifications to the LiteLLM code that allows it to continue to work but just wanted to bring it to attention in case it helped anyone else and could be fixed in the upstream LiteLLM code.

[Chesars]

Unfortunately, this is not a viable solution when using OpenWebUI as-is because the summary included as part of the reasoning_effort dictionary is not supported. I believe this is because in the completions API, summary is not a valid parameter. Summary included in the reasoning_effort dict is only supported in the responses API.

I made my own modifications to the LiteLLM code that allows it to continue to work but just wanted to bring it to attention in case it helped anyone else and could be fixed in the upstream LiteLLM code.

Hi @jasonpnnl,

Thanks for the clarification. In PR #18688, it was added the LITELLM_REASONING_AUTO_SUMMARY flag.

OpenAI's Chat Completions API doesn't support reasoning summaries - only the Responses API has the summary parameter. And even there, it's opt-in and requires a verified organization. Since the Chat Completions → Responses API bridge is a non-standard LiteLLM feature, we made it opt-in to avoid breaking requests for non-verified orgs.

You can enable automatic reasoning summaries with:

# Environment Variable:
export LITELLM_REASONING_AUTO_SUMMARY=true

import litellm
litellm.reasoning_auto_summary = True

#  Proxy Config:
litellm_settings:
    reasoning_auto_summary: true

Docs: https://docs.litellm.ai/docs/reasoning_content | https://docs.litellm.ai/docs/proxy/config_settings

[jasonpnnl]

Hello, again. I did attempt to use LITELLM_REASONING_AUTO_SUMMARY by itself, but sadly found this was not sufficient.

It looks like @Sameerlite applied an almost identical fix as I did in my local instance in #18688 which resolves the issue.

Thanks to you both for your help and to @Sameerlite for reading my mind as I'm not currently able to make the contributions myself.

[Chesars]

Hello, again. I did attempt to use LITELLM_REASONING_AUTO_SUMMARY by itself, but sadly found this was not sufficient.

It looks like @Sameerlite applied an almost identical fix as I did in my local instance in #18688 which resolves the issue.

Thanks to you both for your help and to @Sameerlite for reading my mind as I'm not currently able to make the contributions myself.

It seems the flag will be available in the next release. Thanks to you!