Move function calling to the Responses API

Which models reject Chat Completions tools

The Using GPT-6 guide says GPT-6 Astra and GPT-6.1 Sol support Chat Completions, but tool calling requires the Responses API. The same guide says GPT-6 Sol and GPT-6 Luna support function calling in Chat Completions only with reasoning_effort set to none.

The GPT-6.1 Sol model page says to use the Responses API for tool calling, that Chat Completions is supported without tool calling, and that none and minimal are not supported. The reasoning guide says setting reasoning effort to none on GPT-6 Astra returns HTTP 400, and that GPT-6.1 Sol does not support none or minimal and defaults to medium.

GitHub issue langflow-ai/openrag#2534 records this sentence for gpt-6.1-sol: Function tools with reasoning_effort are not supported for gpt-6.1-sol in /v1/chat/completions. To use function tools, use /v1/responses or set reasoning_effort to 'none'. That second option is not valid for gpt-6.1-sol or gpt-6-astra. It is valid for gpt-6-luna. The full write-up is the gpt-6.1-sol error page.

Sources: Using GPT-6 , GPT-6.1 Sol model page , GPT-6 Astra model page , GPT-6 Luna model page , Reasoning guide , GitHub issue langflow-ai/openrag#2534 , checked October 25, 2026.

Request shape

The migration guide says Chat Completions function definitions are externally tagged, and Responses function definitions are internally tagged. In Chat Completions the name sits inside a function object. In Responses, name, description, and parameters sit next to type.

Chat Completions functions are non-strict by default. If you omit strict on Responses, the API tries to make the schema strict. When it cannot, it falls back to non-strict and returns the tool with strict set to false. Set strict to false when you want that behavior on purpose.

Text-only messages can be passed as input. A system message in that list still works for a text call. Tool calls are a different item type, so a tool loop cannot keep using the Chat Completions message array as-is.

response = client.chat.completions.create(
    model="gpt-6.1-sol",
    messages=[{"role": "user", "content": "What is the weather in Paris?"}],
    tools=[{
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the weather for a city.",
            "parameters": {
                "type": "object",
                "properties": {"location": {"type": "string"}},
                "required": ["location"],
            },
        },
    }],
)

response = client.responses.create(
    model="gpt-6.1-sol",
    input=[{"role": "user", "content": "What is the weather in Paris?"}],
    tools=[{
        "type": "function",
        "name": "get_weather",
        "description": "Get the weather for a city.",
        "parameters": {
            "type": "object",
            "properties": {"location": {"type": "string"}},
            "required": ["location"],
        },
    }],
)

const response = await client.chat.completions.create({
  model: "gpt-6.1-sol",
  messages: [{ role: "user", content: "What is the weather in Paris?" }],
  tools: [{
    type: "function",
    function: {
      name: "get_weather",
      description: "Get the weather for a city.",
      parameters: {
        type: "object",
        properties: { location: { type: "string" } },
        required: ["location"],
      },
    },
  }],
});

const response = await client.responses.create({
  model: "gpt-6.1-sol",
  input: [{ role: "user", content: "What is the weather in Paris?" }],
  tools: [{
    type: "function",
    name: "get_weather",
    description: "Get the weather for a city.",
    parameters: {
      type: "object",
      properties: { location: { type: "string" } },
      required: ["location"],
    },
  }],
});

Sources: Migrate to the Responses API , Function calling , checked October 25, 2026.

Tool results

The function calling guide says a function call is an output item whose type is function_call. It has a call_id, a name, and JSON-encoded arguments. Your application runs the function. The next request appends a function_call_output item with that call_id and the output string.

The reasoning guide says to pass back the reasoning items returned with the function call, plus the function call items and the function call output items, since the last user message. Dropping those items is one of the migration errors the migration guide lists.

Responses are stored by default. Set store to false when you do not want that. If the flow must stay stateless, the migration guide says to preserve each returned reasoning item, which includes encrypted_content by default, and send those items on the next request.

input_list += response.output
for item in response.output:
    if item.type == "function_call" and item.name == "get_weather":
        input_list.append({
            "type": "function_call_output",
            "call_id": item.call_id,
            "output": "15 C",
        })
response = client.responses.create(
    model="gpt-6.1-sol",
    tools=tools,
    input=input_list,
)
print(response.output_text)

import { toResponseInputItems } from "openai/lib/responses/ResponseInputItems";

const toolCall = response.output.find((item) => item.type === "function_call");
input.push(...toResponseInputItems(response.output));
input.push({
  type: "function_call_output",
  call_id: toolCall.call_id,
  output: "15 C",
});
response = await client.responses.create({
  model: "gpt-6.1-sol",
  tools,
  input,
});
console.log(response.output_text);

Sources: Function calling , Reasoning guide , Migrate to the Responses API , checked October 25, 2026.

Streaming

The migration guide says Chat Completions streaming returns chunks with a delta field. Responses streaming uses typed server-sent events. A text stream includes response.created, response.output_text.delta, response.completed, and error.

A function-calling stream also emits response.function_call_arguments.delta and response.function_call_arguments.done. The function calling guide accumulates arguments by listening for response.output_item.added when the item type is function_call, then appending each delta onto that item's arguments.

final_tool_calls = {}
stream = client.responses.create(
    model="gpt-6.1-sol",
    input=[{"role": "user", "content": "What is the weather in Paris?"}],
    tools=tools,
    stream=True,
)
for event in stream:
    if event.type == "response.output_item.added":
        final_tool_calls[event.output_index] = event.item
    elif event.type == "response.function_call_arguments.delta":
        index = event.output_index
        if final_tool_calls[index]:
            final_tool_calls[index].arguments += event.delta

const finalToolCalls = {};
const stream = await client.responses.create({
  model: "gpt-6.1-sol",
  input: [{ role: "user", content: "What is the weather in Paris?" }],
  tools,
  stream: true,
});
for await (const event of stream) {
  if (event.type === "response.output_item.added" && event.item.type === "function_call") {
    finalToolCalls[event.output_index] = event.item;
  } else if (event.type === "response.function_call_arguments.delta" && finalToolCalls[event.output_index]) {
    finalToolCalls[event.output_index].arguments += event.delta;
  }
}

Sources: Migrate to the Responses API , Function calling , checked October 25, 2026.

Gotchas

The migration guide lists these mistakes when a Chat Completions client is pointed at Responses.

• Reading choices[0].message.content instead of output_text or output.
• Treating every output entry as a message. Reasoning items, function calls, and function results are separate item types.
• Dropping reasoning items, function call items, or function call output items when you build the next input yourself.
• Sending a function result without the matching call_id.
• Sending response_format. Responses uses text.format.
• Reusing a Chat Completions stream handler that only reads delta chunks.
• Assuming previous_response_id makes earlier turns free. Previous input tokens in the chain are still billed as input tokens.
• Setting reasoning_effort to none on gpt-6.1-sol or gpt-6-astra because the Chat Completions error mentions it. Those models do not support none.

Sources: Migrate to the Responses API , Using GPT-6 , GPT-6.1 Sol model page , checked October 25, 2026.

LiteLLM

LiteLLM's OpenAI provider says a model string with the openai/ prefix calls Chat Completions. Prefix one call with openai/responses/ to send that call to the Responses API. The page shows openai/responses/gpt-6.1-sol for a request that includes tools and reasoning_effort.

The same page says gpt-6.1-sol without that prefix uses Chat Completions, and that a built-in tool such as web_search_preview fails on that path. It says LiteLLM drops reasoning_effort on tool calls for gpt-5.4, gpt-5.5, and future 5.x releases, because that pair is only supported on the Responses API. The sample on that page uses openai/responses/gpt-6.1-sol and says LiteLLM also routes a call to /v1/responses when both tools and reasoning_effort are set. Do not send none. The GPT-6.1 Sol model page says none is not supported.

import litellm
response = litellm.completion(
    model="openai/responses/gpt-6.1-sol",
    messages=[{"role": "user", "content": "What is the weather in Paris?"}],
    reasoning_effort="low",
    tools=[{
        "type": "function",
        "function": {
            "name": "get_weather",
            "parameters": {
                "type": "object",
                "properties": {"location": {"type": "string"}},
                "required": ["location"],
            },
        },
    }],
)

Sources: LiteLLM OpenAI provider , GPT-6.1 Sol model page , checked October 25, 2026.

Vercel AI SDK

The AI SDK OpenAI guide says openai('model-id') uses the Responses API, and that this has been the default since AI SDK 5. openai.chat('model-id') calls Chat Completions. Use that factory when a custom base URL implements Chat Completions and not Responses.

The same guide says to use the Responses API for GPT-6 tool calling. GPT-6 Astra and GPT-6.1 Sol do not support reasoningEffort none. GPT-6 Sol and GPT-6 Luna do.

import { openai } from "@ai-sdk/openai";
import { generateText, tool } from "ai";
import { z } from "zod";

const result = await generateText({
  model: openai("gpt-6.1-sol"),
  prompt: "What is the weather in Paris?",
  tools: {
    get_weather: tool({
      description: "Get the weather for a city.",
      inputSchema: z.object({ city: z.string() }),
    }),
  },
});

Source: AI SDK OpenAI guide , checked October 25, 2026.

LangChain

The ChatOpenAI page says ChatOpenAI routes to the Responses API when you use a feature that requires it, such as the built-in web search tool. You can also set use_responses_api to True. The gpt-6-astra examples on that page set that flag.

The page says async tools are only supported via the Responses API, and that an additional_tools content block requires it. On Chat Completions, ChatOpenAI raises ValueError for that block. A bind_tools example on the same page uses ChatOpenAI without use_responses_api. The Using GPT-6 guide says gpt-6.1-sol and gpt-6-astra tool calling requires Responses, so set use_responses_api to True for those function tools.

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-6.1-sol", use_responses_api=True)

Sources: LangChain ChatOpenAI , Using GPT-6 , checked October 25, 2026.

Pipecat

Pipecat documents two OpenAI text services. OpenAILLMService is the chat completions service. OpenAIResponsesLLMService and OpenAIResponsesHttpLLMService call the Responses API. The Responses page says to use OpenAILLMService for Chat Completions and the Responses classes for the Responses API.

Both services document function calling through register_function. The Responses page does not name gpt-6.1-sol or gpt-6-astra. The model setting is the OpenAI model id. A pipeline that still constructs OpenAILLMService is still on Chat Completions, which is the endpoint OpenAI says cannot run function tools for those two models.

from pipecat.services.openai.responses.llm import OpenAIResponsesLLMService

llm = OpenAIResponsesLLMService(
    settings=OpenAIResponsesLLMService.Settings(model="gpt-6.1-sol"),
)

Sources: Pipecat OpenAI LLM , Pipecat OpenAI Responses LLM , Using GPT-6 , checked October 25, 2026.

Questions