openai-python 3.49.0 and openai-node 7.55.0: typed async function tools for the Agents API

openai-python v3.49.0 and openai-node v7.55.0 released within minutes of each other on 2026-11-10 around 06:47Z, with one shared main change: typed support for the existing async setting on the beta Agents API function-tool shapes (python #4264, node #3140 - both titled add typed async function tools). Every fact in this article was checked the same day against the GitHub API (release objects and PR bodies), the PR diffs, and the v3.49.0 / v7.55.0 tag sources; the immediately-previous versions (v3.48.0 / v7.54.0) were pulled as baselines to confirm the fields are genuinely new.

1. Versions and shipping timeline

Both release notes carry the same feature line: api: add typed async function tools. python adds one fix on top; node has no functional change beyond the feature.

2. Which shapes changed: the four function variants of beta Agents

The four new fields sit on two request/response pairs of the beta Agents tool types:

These shapes serve the three beta Agents resources - agents, sessions, and automations; the node test changes line up, with function-tool fixtures in the agents, automations, and sessions test files all adding async: true. Scope boundary: the diff touches only these four shapes; Responses API function-tool types are not part of it (see section 5).

3. python: the async_ alias field and the reserved-keyword TypedDict

Response model, quoted from the v3.49.0 agent_tool.py (PersistedAgentToolResourceFunction is identical in shape):

class AgentToolResourceFunction(BaseModel):
    """A function defined by the application."""

    defer_loading: bool
    """Whether the function is deferred and discovered through tool search."""

    description: str
    """A description of what the function does."""

    name: str
    """The name of the function."""

    parameters: Dict[str, object]
    """A JSON Schema object describing the function's arguments."""

    type: Literal["function"]
    """The type of the object. Always `function`."""

    async_: Optional[bool] = FieldInfo(alias="async", default=None)
    """Whether the agent continues without waiting for the function result."""

On the request side, async is a Python reserved word while a TypedDict can carry it as a string key, so the generator organizes it through a reserved-keyword mixin (from agent_tool_param.py):

_AgentToolConfigParamFunctionReservedKeywords = TypedDict(
    "_AgentToolConfigParamFunctionReservedKeywords",
    {
        "async": bool,
    },
    total=False,
)


class AgentToolConfigParamFunction(_AgentToolConfigParamFunctionReservedKeywords, total=False):
    """A function defined by the application."""

The PR body adds two serialization facts: callers previously had to read the undeclared extra via getattr(tool, 'async') or tool.model_extra['async'] and can now read tool.async_ directly; and model_dump(by_alias=True, exclude_unset=True) preserves true, false, and omission, while a bare model_dump(by_alias=True) writes async: None for omitted values.

4. node: the async property on four interfaces

In the v7.55.0 agents.ts, each of the four interfaces gains one member (the two request-side docstrings add the Defaults to false sentence; quoting the tail of AgentToolConfigParamFunction):

export interface AgentToolConfigParamFunction {
  /**
   * A description of what the function does.
   */
  description: string;

  /**
   * The name of the function.
   */
  name: string;

  /**
   * A JSON Schema object describing the function's arguments.
   */
  parameters: { [key: string]: unknown };

  /**
   * The type of the object. Always `function`.
   */
  type: 'function';

  /**
   * Whether the agent continues without waiting for the function result. Defaults to
   * `false`.
   */
  async?: boolean;
}

Baseline comparison (the immediately-previous version, as this site's discipline requires): in the v7.54.0 agents.ts, async?: appears only on the two Compaction interfaces (the background-compaction switch) - zero occurrences on function-tool shapes; the v3.48.0 agent_tool.py has zero async_. Both fields are genuinely new in this pair, not pre-existing.

5. Relation to existing async tool calling: typing, not a new mechanism

Three boundaries, each with a same-day reproducible source:

• The capability itself predates this batch. The node PR body reads: callers have been gaining typed access to the existing async setting. The Responses API function-tool param type (responses/function_tool_param.py) carries the optional "async": bool key at both the v3.48.0 and v3.49.0 tags (same reserved-keyword mixin form), and this batch's diff does not touch it.
• This batch's types land only on the beta Agents shapes. The beta Responses function_tool.py has no async_ in either tag - do not describe this batch as the Responses API gaining async.
• The official docs have not caught up here. This batch did not verify any agents-api guide update describing the async field on the AgentTool shapes (the whitelist for this article is the GitHub PRs and tag sources; no documentation claims are made); before production code, trust the actual type files of the version you pin.

6. The python fix in the same release: Microphone.record() PCM WAV encoding

The python release also carries fix #3900 (merged 2026-11-10T02:09:16Z, titled encode microphone recordings as valid PCM WAV; the source change is src/openai/helpers/microphone.py, plus a newly added tests/lib/test_microphone.py). The mechanism per the PR body:

• Before the fix, Microphone.record() wrote every capture dtype straight into an integer-PCM WAV file - float32 IEEE-float bytes were interpreted as signed integers, and int8 silence (0) was interpreted as the most negative sample because 8-bit WAV PCM is unsigned.
• After the fix, float32 recordings are converted to 16-bit PCM and int8 recordings are offset to unsigned 8-bit before writing (with the converted sample width in the header); int16, int32, and uint8 encodings are preserved, as is the original dtype/data when return_ndarray=True.
• The PR body describes regression tests driving the public record() method through a mocked input device across all five supported capture dtypes, stereo metadata, and ndarray returns - with the float32 and int8 WAV cases failing before the fix.

This fix touches only python's local recording helper and has no API-shape relevance; node has no counterpart entry.

7. Common mistakes and troubleshooting

• Reading the response field: use tool.async_ in python - tool.async is a syntax error, and model_extra is no longer the place to look now that the field is declared.
• A stray null after serialization: model_dump(by_alias=True) without exclude_unset=True emits async: None; normalize dump arguments before replaying or diffing request bodies.
• Do not write that the Responses API gained async: this batch's types live on the four beta Agents shapes; the Responses-side request key already existed (verified against the v3.48.0 tag).
• The docstring asymmetry is not a typo: node request-side docstrings add Defaults to false and response-side ones do not - the tag sources are like that on each side; quote them per side.

Next steps

• The previous SDK pair (3.48.0 / 7.54.0): openai-python 3.48.0 and openai-node 7.54.0: agent session event-stream obfuscation padding and stream_options.
• Existing agent session settings - compaction, review, spend controls: openai-python 3.42.0 and openai-node 7.46/7.47: agent compaction and review settings, external keys, SIP DTMF.
• Every OpenAI release node on one timeline: OpenAI Models Release Notes (2026, Living Document).