Describe the bug
With the Responses instrumentor active, client.responses.with_raw_response.create(..., stream=True) no longer returns a raw response. It returns AsyncStreamWrapper, which:
- does not expose
.parse() or .headers, both part of the with_raw_response contract; and
- cannot be iterated, because its
stream_async_iter is the still-unparsed LegacyAPIResponse, which has no __anext__.
So any caller that uses with_raw_response together with streaming breaks as soon as tracing is enabled, with:
AttributeError: 'LegacyAPIResponse' object has no attribute '__anext__'
with_raw_response is the only way to read response headers (e.g. x-ms-served-model) while streaming, so this affects callers that need per-response header data.
Root cause
The instrumentor patches openai.resources.responses.AsyncResponses.create. with_raw_response.create() delegates to that same method, but sets the SDK's raw-response flag, so create returns a LegacyAPIResponse rather than an AsyncStream.
_wrap_async_streaming_response treats whatever create returned as the event stream and stores it as stream_async_iter, and AsyncStreamWrapper.__anext__ calls self.stream_async_iter.__anext__(). For the raw-response path that object is a LegacyAPIResponse, which is not an async iterator — it must have .parse() called on it first.
Verified with a debug hook on _wrap_async_streaming_response:
[wrap] _wrap_async_streaming_response receives stream=openai._legacy_response.LegacyAPIResponse
To Reproduce
Standalone: openai + azure-ai-projects only, no Azure resources needed (the transport is mocked, so the object graph is wrong before any real network call matters).
import asyncio
import httpx
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from azure.core.settings import settings
from azure.core.tracing.ext.opentelemetry_span import OpenTelemetrySpan
from azure.ai.projects.telemetry._responses_instrumentor import ResponsesInstrumentor
from openai import AsyncOpenAI
trace.set_tracer_provider(TracerProvider())
settings.tracing_implementation = OpenTelemetrySpan
SSE = (
'data: {"type":"response.output_text.delta","delta":"Hello","item_id":"m1",'
'"output_index":0,"content_index":0,"sequence_number":1,"logprobs":[]}\n\n'
"data: [DONE]\n\n"
)
transport = httpx.MockTransport(
lambda r: httpx.Response(200, headers={"content-type": "text/event-stream"}, content=SSE.encode())
)
async def main() -> None:
ResponsesInstrumentor().instrument()
client = AsyncOpenAI(api_key="k", http_client=httpx.AsyncClient(transport=transport))
raw = await client.responses.with_raw_response.create(model="gpt-4o", input="hi", stream=True)
print(f"returned type : {type(raw).__module__}.{type(raw).__name__}")
print(f" .parse() : {hasattr(raw, 'parse')}")
print(f" .headers : {hasattr(raw, 'headers')}")
inner = getattr(raw, "stream_async_iter", None)
print(f" .stream_async_iter: {type(inner).__module__}.{type(inner).__name__}")
print(f" __anext__ : {hasattr(inner, '__anext__')}")
async for _ in raw:
pass
asyncio.run(main())Note both an OpenTelemetry TracerProvider and azure-core-tracing-opentelemetry are required — without them _create_responses_span_from_parameters returns None, the instrumentor returns the result unwrapped, and the bug does not appear. That makes it easy to miss when reproducing.
Expected behavior
with_raw_response.create(..., stream=True) should keep behaving like a raw response when tracing is on: .parse() and .headers available, and the parsed stream iterable — ideally with the wrapper still in the iteration path so telemetry is still recorded.
Actual behavior
returned type : azure.ai.projects.telemetry._responses_instrumentor.AsyncStreamWrapper
.parse() : False <- raw-response API expects True
.headers : False <- raw-response API expects True
.stream_async_iter: openai._legacy_response.LegacyAPIResponse
__anext__ : False <- wrapper iterates this
iterating the returned object:
AttributeError: 'LegacyAPIResponse' object has no attribute '__anext__'
With the instrumentor uninstrumented, the same call correctly returns:
openai._legacy_response.LegacyAPIResponse .parse()=True .headers=True
Environment
azure-ai-projects==2.3.0openai==2.53.0azure-core-tracing-opentelemetry==1.0.0b13, opentelemetry-sdk==1.44.0- Python 3.13, macOS (not platform specific)
Notes
Reported downstream as microsoft/agent-framework#7461, where enabling AZURE_EXPERIMENTAL_ENABLE_GENAI_TRACING=true made all streaming agent requests fail. microsoft/agent-framework#7705 works around it by parsing the wrapper's inner raw response and handing it back, so the wrapper stays in the iteration path and telemetry is preserved. That workaround could be dropped once this is fixed upstream.
Describe the bug
With the Responses instrumentor active,
client.responses.with_raw_response.create(..., stream=True)no longer returns a raw response. It returnsAsyncStreamWrapper, which:.parse()or.headers, both part of thewith_raw_responsecontract; andstream_async_iteris the still-unparsedLegacyAPIResponse, which has no__anext__.So any caller that uses
with_raw_responsetogether with streaming breaks as soon as tracing is enabled, with:with_raw_responseis the only way to read response headers (e.g.x-ms-served-model) while streaming, so this affects callers that need per-response header data.Root cause
The instrumentor patches
openai.resources.responses.AsyncResponses.create.with_raw_response.create()delegates to that same method, but sets the SDK's raw-response flag, socreatereturns aLegacyAPIResponserather than anAsyncStream._wrap_async_streaming_responsetreats whatevercreatereturned as the event stream and stores it asstream_async_iter, andAsyncStreamWrapper.__anext__callsself.stream_async_iter.__anext__(). For the raw-response path that object is aLegacyAPIResponse, which is not an async iterator — it must have.parse()called on it first.Verified with a debug hook on
_wrap_async_streaming_response:To Reproduce
Standalone:
openai+azure-ai-projectsonly, no Azure resources needed (the transport is mocked, so the object graph is wrong before any real network call matters).Note both an OpenTelemetry
TracerProviderandazure-core-tracing-opentelemetryare required — without them_create_responses_span_from_parametersreturnsNone, the instrumentor returns the result unwrapped, and the bug does not appear. That makes it easy to miss when reproducing.Expected behavior
with_raw_response.create(..., stream=True)should keep behaving like a raw response when tracing is on:.parse()and.headersavailable, and the parsed stream iterable — ideally with the wrapper still in the iteration path so telemetry is still recorded.Actual behavior
With the instrumentor uninstrumented, the same call correctly returns:
Environment
azure-ai-projects==2.3.0openai==2.53.0azure-core-tracing-opentelemetry==1.0.0b13,opentelemetry-sdk==1.44.0Notes
Reported downstream as microsoft/agent-framework#7461, where enabling
AZURE_EXPERIMENTAL_ENABLE_GENAI_TRACING=truemade all streaming agent requests fail. microsoft/agent-framework#7705 works around it by parsing the wrapper's inner raw response and handing it back, so the wrapper stays in the iteration path and telemetry is preserved. That workaround could be dropped once this is fixed upstream.