top of page

OpenAI API tool calls fail with "Function tools with reasoning_effort are not supported": every cause and fix

4 minutes ago
9 min read
OpenAI API tool calls failing with the reasoning_effort error in Chat Completions, Data Studios original cover

Last verified: November 21, 2026


Developers who move an existing app from an older GPT model to a GPT-5.6 or GPT-6 model often hit the same wall: the first request that includes tools comes back with an HTTP 400 error, even though the code has not changed and the model page says function calling is supported. The message says that function tools cannot be combined with reasoning in the Chat Completions endpoint, and it offers two ways out. The fix is to send tool calls through the Responses API, or to turn reasoning off with reasoning_effort set to "none" on models that still accept that value. Which of the two works depends on the model, because the newest OpenAI models no longer accept "none" at all.


The error affects code that calls the Chat Completions endpoint directly and, far more often, apps and frameworks that use it under the hood: chat front ends, agent SDKs, CMS plugins and workflow tools. Reports on the OpenAI Developer Community and on GitHub start in July 2026 with the GPT-5.6 family (Sol, Luna and Terra) and continue with GPT-6 Sol in October. The OpenAI documentation now states the rule model by model, and the same error text appears in Microsoft's Azure OpenAI documentation for the same models. Many users run into it without ever setting a reasoning value themselves, because these models reason by default.


··········


THE EXACT OPENAI ERROR MESSAGE AND WHERE IT APPEARS.


The API returns a 400 response with type invalid_request_error and the parameter reasoning_effort. The model name inside the message changes with the model you called. This is the full text as it appears in the Azure OpenAI documentation and in several bug reports:


Function tools with reasoning_effort are not supported for gpt-5.6-sol in /v1/chat/completions. To use function tools, use /v1/responses or set reasoning_effort to 'none'.

In apps built on top of the API, the same text is usually wrapped in the app's own log line. LibreChat logs it as "400 Function tools with reasoning_effort are not supported for gpt-5.6-terra", the Drupal OpenAI provider logs it after "Error invoking model response:", and the OpenAI Agents SDK for Python raises it as "Error code: 400" followed by the JSON error body. If you see any of these, the cause is the same request pattern: a Chat Completions call that includes function tools while reasoning is active.


··········


WHY OPENAI REASONING MODELS REJECT TOOLS IN CHAT COMPLETIONS.


OpenAI's reasoning guide says plainly that the Responses API is the endpoint to use for function calling with reasoning models. The reason given in the documentation is that reasoning items returned together with function calls have to be passed back along with the tool outputs, so that the model can continue from its own reasoning after each tool call. Chat Completions has no place for those reasoning items, which is why OpenAI restricts the combination there. Chat Completions is still supported, and OpenAI has not announced that it will be removed.


Three facts from the documentation explain almost every report:


1. GPT-5.6 and GPT-6 models reason by default. The reasoning guide gives medium as the default effort for GPT-5.6, GPT-6 Sol, GPT-6 Luna and GPT-6.1 Sol, and the Azure OpenAI reasoning page warns that a request fails even when it does not send reasoning_effort, because the default is already medium. Sending tools alone is enough to trigger the error.


2. On models that still accept "none", Chat Completions allows function tools only when reasoning is switched off. The GPT-6 Sol model page states: "Chat Completions supports function calling only with reasoning_effort set to none."


3. The newest models do not accept "none". The reasoning guide says GPT-6 Astra does not support "none", GPT-6.1 Sol supports neither "none" nor "minimal", and GPT-6.2 Astra and GPT-6.2 Sol reject requests that set effort to "none". For these models, tool calling has to move to the Responses API.


The table below sums up what the official pages say for each model family. Where a page gives no statement, the cell says so.


........


Model

Reasoning by default

Accepts "none"

Function tools in Chat Completions

GPT-5.6 Sol, Luna, Terra

Yes, medium

Yes

Only with reasoning_effort "none"

GPT-6 Sol

Yes, medium

Yes

Only with reasoning_effort "none"

GPT-6 Luna

Yes, medium

Reported by users, not on the model page

Users report "none" only

GPT-6 Astra

Yes

No

Not supported, use Responses

GPT-6.1 Sol

Yes, medium

No (nor "minimal")

Not supported, use Responses

GPT-6.2 Astra, GPT-6.2 Sol

Yes

No

Not supported, use Responses


........


The GPT-6.2 model pages still list Chat Completions among the supported endpoints and function calling among the supported features, which confuses many readers. Both statements are true on their own: the models answer Chat Completions requests, and they call functions, but the "Using GPT-6.2" guide adds that tool calling requires Responses.


··········


OPENAI FUNCTION TOOLS ERROR: CAUSES, CHECKS AND FIXES.


The same message can come from five different situations. Checking them in this order usually finds the one that applies.


........


Cause

How to check

Fix

Tools sent to Chat Completions with the default reasoning effort

Request has tools and no reasoning_effort, model is GPT-5.6 or GPT-6 Sol

Set reasoning_effort to "none" on every request with tools, or move to Responses

Model does not accept "none"

Model is GPT-6 Astra, GPT-6.1 Sol or GPT-6.2

Move tool calls to the Responses API

App or framework still uses Chat Completions

Error appears inside a chat app, plugin or agent SDK

Turn on the app's Responses option or update the integration

SDK sends no reasoning setting for new model names

Agents SDK with a GPT-6 model and no explicit reasoning setting

Set reasoning effort to "none" in the model settings, or use the Responses model class

Explicit effort value left over from an older model

Code sets reasoning_effort to low, medium or high together with tools

Remove tools from that call, set "none" where allowed, or switch endpoint


........


··········


FIX 1: MOVE OPENAI TOOL CALLS TO THE RESPONSES API.


This is the fix OpenAI recommends in its reasoning, function calling and GPT-6.2 guides, and the only one that keeps reasoning on while the model calls your functions. It is also the only fix for GPT-6 Astra, GPT-6.1 Sol and the GPT-6.2 models.


1. Change the endpoint from /v1/chat/completions to /v1/responses (in the official SDKs, from client.chat.completions.create to client.responses.create).


2. Replace the messages array with input, and move the system prompt to instructions if you use one.


3. Rename reasoning_effort to the nested form reasoning.effort. The GPT-6.2 guide states the two names: "reasoning.effort" in Responses, "reasoning_effort" in Chat Completions.


4. Flatten the tool definitions. In Responses, the function name, description and parameters sit directly on the tool object instead of inside a nested function object.


5. After each function call, send back the function output together with the reasoning items the model returned, as the reasoning guide requires.


6. For GPT-6.2, remove temperature, top_p and top_logprobs from Responses requests, as listed in the "Using GPT-6.2" migration notes.


The example below is illustrative and uses the parameter names from the OpenAI guides. It sends one function tool to GPT-6.2 Sol with medium reasoning, the starting value the GPT-6.2 guide suggests for a new integration.


# Illustrative example: Responses API request with a function tool and reasoning
curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6.2-sol",
    "reasoning": {"effort": "medium"},
    "tools": [{
      "type": "function",
      "name": "get_weather",
      "description": "Get the current weather for a city",
      "parameters": {
        "type": "object",
        "properties": {"city": {"type": "string"}},
        "required": ["city"]
      }
    }],
    "input": "What is the weather in Rome right now?"
  }'

One behavior change comes with the move. OpenAI's function calling guide says Responses requests try to normalize function schemas into strict mode when possible, while Chat Completions requests stay non-strict by default, so a loose schema that worked before may now be rejected with a list of the missing constraints.


··········


FIX 2: SET OPENAI REASONING_EFFORT TO "NONE" IN CHAT COMPLETIONS.


If you cannot change endpoints yet, and the model accepts "none", turning reasoning off removes the error immediately. OpenAI's own Chat Completions function calling examples use gpt-5.6-terra with reasoning_effort set to "none". The price is answer quality on harder tasks, since the model no longer reasons before choosing a tool.


1. Confirm the model accepts "none": GPT-5.6 Sol, Luna and Terra and GPT-6 Sol do, according to the documentation. Do not use it with GPT-6 Astra, GPT-6.1 Sol or GPT-6.2, which answer with a 400 error.


2. Set reasoning_effort to "none" on every request that includes tools, including follow-up requests that only send tool results.


3. In the .NET library, the Azure documentation sets ChatCompletionOptions.ReasoningEffortLevel to ChatReasoningEffortLevel.None. The property is marked experimental with the diagnostic OPENAI001, which has to be suppressed with a pragma or a NoWarn entry before the code compiles.


4. Treat this as a temporary step. The GPT-6.2 guide tells developers who use "none" or "minimal" today to use "low" instead on the new models, and "low" with tools works only in Responses.


# Illustrative example: Chat Completions with tools and reasoning switched off
from openai import OpenAI

client = OpenAI()
response = client.chat.completions.create(
    model="gpt-5.6-terra",
    reasoning_effort="none",
    messages=[{"role": "user", "content": "What is the weather in Rome right now?"}],
    tools=[{
        "type": "function",
        "function": {
            "name": "get_weather",
            "parameters": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"]
            }
        }
    }],
)

··········


FIX 3: OPENAI ERRORS INSIDE APPS, PLUGINS AND AGENT SDKS.


When the error appears in a tool you did not write, the request is built by that tool, and the fix is a setting or an update on its side. The cases below are documented in public issue trackers.


........


Tool

What the reports show

What to do

OpenAI Agents SDK for Python

Issue reported on version 0.19.2: default settings recognize GPT-5 names only, so GPT-6 calls go out with no reasoning setting

Set reasoning effort to "none" in the agent's model settings, or use the Responses model

LibreChat

Defaults to Chat Completions and sends reasoning_effort to gpt-5.6 models

Enable the "Use Responses API" option for the conversation or agent

Drupal OpenAI provider

Version 1.2.x fails with gpt-5.6-luna

Set reasoning effort to "none" on 1.2.x; the maintainer says 1.3.x uses Responses

Visual Studio Copilot with a custom GPT-5.6 model

Same 400 error, no workaround found in the forum thread

Use a model the integration supports until it is updated


........


In the Agents SDK issue, a repository collaborator confirmed the behavior: GPT-6 Sol reasons by default, Chat Completions accepts function tools only when reasoning is explicitly "none", and GPT-6.1 Sol needs Responses for tools because it does not accept "none". Proxies and gateways that forward requests to OpenAI pass the error through unchanged, so a 400 from a gateway with this text comes from OpenAI and has to be fixed in the request itself.


··········


WHAT OPENAI DOCUMENTS AND WHAT IS ONLY REPORTED BY DEVELOPERS.


The rules in the model table come from OpenAI's reasoning guide, function calling guide, the "Using GPT-6.2" guide and the GPT-6 Sol and GPT-6.2 Sol model pages. The default-effort trap and the .NET fix are documented by Microsoft for Azure OpenAI, which uses the same error text. On the OpenAI Developer Community, an OpenAI Support account replied in September that Responses supports the tool workflow and that no fix had been confirmed for this exact Chat Completions combination.


Two points rest on user reports only. One forum user wrote that blocking function tools on reasoning models in Chat Completions began with gpt-5.4, which OpenAI has not confirmed in the pages checked. Developers migrating to GPT-6 Luna report that it still accepts "none" with tools in Chat Completions, while the OpenAI pages checked give no statement on it. Treat both as likely but unconfirmed, and test with your own key before relying on them.


··········


HOW TO AVOID THE OPENAI TOOLS ERROR AFTER THE NEXT MODEL UPDATE.


The pattern so far is clear: each new top model has dropped one more low effort value and kept tool calling in Responses only. Code that depends on reasoning_effort "none" in Chat Completions will need to change again with the next release.


1. Before switching model names in production, read the model page and the "Using GPT-6.2" guide (or its successor) for three items: accepted effort values, the default value, and whether tool calling requires Responses.


2. Log the full error body. The error names the model and the parameter, which is enough to tell this case apart from other 400 errors such as unsupported temperature or token-limit parameters.


3. Avoid error handlers that retry without tools when a message mentions tools. They hide the problem and return answers in which the model never called your functions.


4. Remove sampling parameters on the new models. The GPT-6.2 guide says to omit temperature, top_p, logprobs and top_logprobs in Chat Completions, a separate source of 400 errors covered in our page on the unsupported temperature parameter.


5. Check token limits at the same time. Reasoning models use max_completion_tokens in Chat Completions, as explained in our page on max_tokens not supported errors.


For the models themselves, prices and the differences between Astra and Sol, see our report on the GPT-6.2 Astra and Sol launch and API pricing.


··········


OPENAI FUNCTION TOOLS AND REASONING_EFFORT: THE FIX BY MODEL.


The error is a documented restriction of the Chat Completions endpoint and does not point to a bug in your code or a problem with your account. On GPT-5.6 models and GPT-6 Sol, setting reasoning_effort to "none" on every request with tools makes the error disappear, at the cost of reasoning. On GPT-6 Astra, GPT-6.1 Sol, GPT-6.2 Astra and GPT-6.2 Sol, that value is rejected, and the Responses API is the only way to use function tools, with reasoning items passed back after each call. Leaving reasoning_effort out does not help on any of these models, because they reason at medium effort by default.


For apps and frameworks, the fastest fix is the integration's own Responses option or an update to a version that uses Responses. OpenAI has not announced any change that would allow reasoning and function tools together in Chat Completions, and the direction of its last three model releases points the other way.


··········


FOLLOW US FOR MORE.


·····


DATA STUDIOS


·····


datastudios.org


bottom of page