Python: [Bug]: OpenAI RAPI no longer requires the call id on a function call result

[TaoChenOSU]

Description

As described in the title: https://developers.openai.com/api/reference/resources/responses/methods/create#(resource)%20responses%20%3E%20(method)%20create%20%3E%20(params)%200.non_streaming%20%3E%20(param)%20input%20%3E%20(schema)%20%3E%20(variant)%201%20%3E%20(items)%20%3E%20(variant)%208%20%3E%20(property)%20call_id

Our OpenAI integration still requires a call_id on the function result content:

@classmethod
    def from_function_result(
        cls: type[ContentT],
        call_id: str,
        *,
        result: Any = None,
        exception: str | None = None,
        annotations: Sequence[Annotation] | None = None,
        additional_properties: MutableMapping[str, Any] | None = None,
        raw_representation: Any = None,
    ) -> ContentT:

And our OpenAI integration drops function result contents that don't have a call id:

case "function_call":
      if not content.call_id:
          logger.warning(f"FunctionCallContent missing call_id for function '{content.name}'")
          return {}

Code Sample

This hasn't triggered any issue yeah but translating the function result contents between OpenAI spec compatible SDKs and MAF content type is awkward. The following code will raise a Pylance warning:

Content.from_function_result(item.get("call_id"), result=output)
"""
Argument of type "str | None" cannot be assigned to parameter "call_id" of type "str" in function "from_function_result"
  Type "str | None" is not assignable to type "str"
    "None" is not assignable to "str"
"""

Package Versions

agent-framework-core, agent-framework-openai

Additional Context

We need to check what the services actually expects.

[mikemikimike]

Implemented in PR #7928.

• Changed: Content.from_function_result now accepts an omitted call ID, and the OpenAI Responses serializer omits call_id when it is absent while preserving supplied IDs.
• Tests: The full OpenAI package non-integration suite and focused core factory tests pass.
• Validation: Ruff 0.16.3 checks, targeted Pyright, and builds for both affected packages pass. The full core sweep is limited by optional workspace dependencies that are not installed in this checkout.

[JHf0912]

I've opened PR #8041 implementing this: Content.from_function_result now accepts call_id: str | None = None, and the Responses client omits the call_id key in function_call_output items when it is absent. Feedback welcome!

[eavanvalkenburg]

After #7988 and review of #7928/#8041, this needs a Responses-specific redesign rather than a global relaxation of Content.from_function_result().

Why

Agent Framework now deliberately separates two identities:

• Content.id: stable identity of one local call occurrence.
• call_id: provider/service correlation between a call and its terminal result.

The local function loop, approval binding, history, and compaction all rely on results being correlated. Making core function results anonymous would create an ambiguous state that other providers and framework layers cannot handle safely.

The OpenAI create documentation marks function_call_output.call_id optional, but the supported OpenAI Python SDK request type currently still marks it required. The newer wire shape also includes caller, name, namespace, and item id; those may provide context or alternate identity, but neither proposed PR established the valid combinations or modeled them.

Required redesign

1. Verify with OpenAI and Azure OpenAI contract tests which function_call_output shapes are accepted when call_id is absent, including requirements for caller, name, namespace, and id.
2. Define a typed Responses wire representation where call_id may be absent and the alternate fields are preserved.
3. Keep AF-local executable function_result content correlated. Convert an id-less wire output to ordinary AF function-result content only when a trustworthy correlation can be established.
4. Otherwise retain it as protocol-native/informational extension data or reject it at a boundary that requires local call/result pairing; do not silently make it executable.
5. Apply one tested policy across agent-framework-openai, Hosting Responses, Foundry hosting, and DevUI, with round-trip fixtures. Check .NET parity separately because MEAI and .NET AF currently require call IDs.
6. Update the function-calling specification only after the valid wire and AF mapping contract is settled.

When

Handle this as part of the planned typed Responses conversion consolidation (the team is working on this), before migrating shared function-call/result conversion into the common Responses layer. That is the point where the complete wire object—including alternate identity fields—can be modeled once. Until then, keep call_id required for provider-neutral AF function results and rely on #7988's generated effective ID for actionable local calls that arrive without one.

[JHf0912]

Following up on my closed PR #8041 and the discussion on #7928: the direction is clear now — model the Responses API's id-less wire combinations (and the newer identity fields) at the Responses boundary, without making anonymous function results generally valid in core.

If it would be useful, I can start by compiling a schema-level matrix of accepted id-less combinations (function_call_output with/without call_id, the caller/name/namespace/item id fields) and draft a boundary-scoped design proposal for review here.

[eavanvalkenburg]

JHf0912
this:

If it would be useful, I can start by compiling a schema-level matrix of accepted id-less combinations (function_call_output with/without call_id, the caller/name/namespace/item id fields) and draft a boundary-scoped design proposal for review here.

is what I am working on, I expect to advance that next week, until then please don't take action on this issue