Is streaming of new "custom" tool calls supported using Chat Completions?

[AmevinLS]

Context:

In the documentation here, an example is given for passing "custom" tools to models using the Chat Completions API.

However, in the chat completion chunk object described here, the choices.delta.tool_calls only seems to support type="function" with no mention of "custom". The same is reflected in the openai python SDK, currently leading to among other things typing issues in downstream custom code.

Question:

So does this mean that streaming from Chat Completions while passing "custom" tools isn't supported? Or perhaps is the API definition incomplete?

Thanks in advance.

[fadighomrani77-byte]

هاي

[antoninche]

Hi!

At the moment, streaming tool calls with Chat Completions isn’t fully supported for “custom” tool types in the official API or SDK. The spec and current SDK implementations only explicitly list support for "function" tool calls in the streaming chunks, and streaming support for other kinds (e.g., custom tool call objects) isn’t documented or surfaced in the typical chat completions streaming responses yet.

In short:

• The API does support streaming text responses (stream: true).
• Tool calls appear in chunk deltas (e.g., choices.delta.tool_calls), but only for type: "function". There’s no official indication that custom tool call chunks are streamed today.
• That means if you send custom tools in tools=[...], the model may produce custom tool call entries in the final response, but these aren’t currently streamed chunk by chunk in chat.completions streaming.

If you need streaming of tool calls or fine-grained streaming of custom tool invocations, one option is to use the Responses API instead — it has richer streaming events and better tooling support for advanced tool interactions, including custom tools. The Responses API is the newer recommended interface for complex agent-style streaming.

Here’s a minimal streaming snippet showing what is supported with function tools:

from openai import OpenAI

client = OpenAI()

stream = client.chat.completions.create(
    model="gpt-5",
    messages=[{"role": "user", "content": "Hello"}],
    tools=[
        {"type": "function", "function": {"name": "my_tool"}}
    ],
    stream=True,
)

for chunk in stream:
    # text arrives chunk by chunk
    print(chunk.choices[0].delta) 

[chasewhughes]

To answer your question directly: no, streaming of custom tool calls is not supported in Chat Completions. The streaming chunk schema (choices.delta.tool_calls) only supports type: "function". This isn't an incomplete spec — it's an intentional limitation of the Chat Completions API.

Why this matters for agent builders:

The Chat Completions API was designed for a request-response model with function calling bolted on. The tool_calls delta in streaming only handles the incremental delivery of function name + arguments as they're generated token by token. "Custom" tool types don't fit this model because the streaming protocol has no way to express arbitrary tool invocation shapes in the delta format.

What to use instead:

The Responses API is the correct path for anything beyond basic function calling. It has:

• Richer streaming events (response.output_item.added, response.function_call_arguments.delta, etc.)
• Native support for built-in tools (web search, code interpreter, file search) alongside custom function tools
• Better event granularity — you get discrete events for each tool invocation rather than multiplexed deltas in a single choices array

from openai import OpenAI

client = OpenAI()

# Responses API with streaming
stream = client.responses.create(
    model="gpt-4o",
    input="Search for the latest AutoGen release",
    tools=[
        {"type": "web_search_preview"},  # built-in tool
        {"type": "function", "function": {"name": "my_tool", ...}},  # custom function
    ],
    stream=True,
)

for event in stream:
    # Each event has a distinct type — no multiplexing
    if event.type == "response.output_text.delta":
        print(event.delta, end="")
    elif event.type == "response.function_call_arguments.delta":
        print(f"[tool arg chunk: {event.delta}]")

The practical tradeoff:

If you're building an agent system and need streaming tool calls, migrate to the Responses API. Chat Completions with type: "function" still works fine for simple single-turn function calling without streaming, but it's a dead end for anything more complex. The Responses API is where OpenAI is investing in the agent-oriented features.

The SDK typing issues you noticed (tool_calls only typing for "function") are downstream of this — the Python SDK correctly reflects the API spec, which only defines function-type tool calls in streaming chunks.