Thanks both — Evan Mattson (@moonbox3) you were right, and the PR is updated.

Verified the failure you described

I reproduced it against the real instrumentor (azure-ai-projects==2.3.0, openai==2.53.0, AZURE_EXPERIMENTAL_ENABLE_GENAI_TRACING=true), with a mocked transport so no Azure resources are needed. The instrumentor needs both an OTel TracerProvider and azure-core-tracing-opentelemetry for _create_responses_span_from_parameters to return a span — without them it returns the result unwrapped and the bug doesn't appear at all, which is what made this easy to miss.

With tracing genuinely active:

[wrap] _wrap_async_streaming_response receives stream=openai._legacy_response.LegacyAPIResponse
with_raw_response.create() -> azure.ai.projects.telemetry._responses_instrumentor.AsyncStreamWrapper
  has .parse()   : False
  has .headers   : False
  .stream_async_iter = openai._legacy_response.LegacyAPIResponse
     has __anext__: False   has parse: True

--- iterating the wrapper directly (what the first commit did) ---
  FAILS: AttributeError: 'LegacyAPIResponse' object has no attribute '__anext__'

Exactly as you said: with_raw_response.create() routes through the instrumented AsyncResponses.create, so stream_async_iter is the still-unparsed LegacyAPIResponse. My first commit just traded one AttributeError for another and traced streaming stayed broken.

You were also right about why the test missed it: it patched with_raw_response.create, which is above the layer that installs the wrapper, so the wrapper's inner raw response never existed in that test.

What changed

_open_event_stream() now parses the raw response the wrapper holds and hands it back, so the wrapper stays in the iteration path and keeps recording telemetry:

inner = getattr(raw_response, "stream_async_iter", None)
inner_parse = getattr(inner, "parse", None)
if callable(inner_parse):
    async with cast("Any", inner_parse()) as stream:
        raw_response.stream_async_iter = stream
        yield raw_response
    return

End-to-end against the real instrumentor now:

raw from with_raw_response : AsyncStreamWrapper
  .stream_async_iter       : LegacyAPIResponse
  _open_event_stream yielded: AsyncStreamWrapper
RESULT: streamed 'Hello world'
telemetry wrapper still in iteration path: True

The test now models that observed object graph — a wrapper with no parse/headers whose stream_async_iter is an unparsed raw response — and fails against my previous commit with AttributeError: '_UnparsedRawResponse' object has no attribute '__aiter__', mirroring the real failure. I added a second test for a bare event stream with nothing to parse, covering the remaining branch.

I kept the fake rather than adding azure-ai-projects as a test dependency, since that would be a heavy dep for this package — happy to add a marked integration test instead if you'd prefer the real thing in CI.

On the two Copilot comments

• callable(parse) — good catch, adopted for both the outer and inner lookups.
• AsyncIterator vs AsyncGenerator — respectfully leaving this as AsyncGenerator. This repo's pinned pyright (1.1.411) reports the opposite as an error: Annotating the return type as -> AsyncIterator[Foo] with @asynccontextmanager is deprecated. Use -> AsyncGenerator[Foo] instead. (reportDeprecated). I had it as AsyncIterator first and pyright failed on it; AsyncGenerator is what keeps the package at 0 errors.

Checks

madanmishra1223 please resolve all open comments if they've been addressed

Python Unit Test Overview

Hi madanmishra1223,

Thanks for the contributions! Could you also create an issue in the Azure SDKs repo and link it here?

Thanks Tao Chen (@TaoChenOSU) — filed upstream: Azure/azure-sdk-for-python#48646

[azure-ai-projects] ResponsesInstrumentor breaks openai with_raw_response streaming (AsyncStreamWrapper wraps an unparsed LegacyAPIResponse)

It has a standalone repro (openai + azure-ai-projects only, mocked transport, no Azure resources) and frames it as the raw-response contract being broken by the instrumentor:

• with_raw_response.create(..., stream=True) returns AsyncStreamWrapper instead of a raw response
• no .parse(), no .headers
• stream_async_iter is the still-unparsed LegacyAPIResponse, so iterating raises AttributeError: 'LegacyAPIResponse' object has no attribute '__anext__'
• uninstrumenting restores the correct LegacyAPIResponse with .parse() / .headers

I called out there that reproducing needs both an OTel TracerProvider and azure-core-tracing-opentelemetry — without them _create_responses_span_from_parameters returns None, the instrumentor returns the result unwrapped, and the bug silently doesn't appear. That tripped me up initially, so it seemed worth stating explicitly for whoever picks it up.

I also linked this PR from that issue and noted the workaround here can be dropped once it's fixed upstream.

One process note: this branch is still showing action_required on the workflows, so the Test Typing Checks fix in c85069cd hasn't been re-verified by CI yet. It passes locally via the task CI uses (poe test-typing -P openai: mypy, pyrefly, ty, zuban, pyright all green) — but it would need a workflow approval to confirm in CI.

Hi madanmishra1223,

Thanks! Please also resolve all open comments when you can.

Tao Chen (@TaoChenOSU) all three review threads are resolved. Since resolving collapses them, here is what each one says, so it is readable without expanding:

1. Copilot — guard parse with callable() (r3799495111)
Adopted. Both lookups now use callable() instead of an is None check, which matters more than it first looked since the helper probes parse on two different objects:

parse = getattr(raw_response, "parse", None)
if callable(parse): ...

inner_parse = getattr(inner, "parse", None)
if callable(inner_parse): ...

2. Copilot — use AsyncIterator instead of AsyncGenerator (r3799495126)
Not applied, deliberately. This repo's pinned pyright reports the opposite as an error. I had it as AsyncIterator first and pyright==1.1.411 failed the package:

Annotating the return type as `-> AsyncIterator[Foo]` with `@asynccontextmanager` is deprecated.
Use `-> AsyncGenerator[Foo]` instead. (reportDeprecated)

Baseline for the package is 0 errors; AsyncIterator took it to 1. Switching back would break Test Typing Checks. Happy to revisit if you would rather match the convention and suppress the rule.

3. Evan Mattson (@moonbox3) — exercise it through the real azure-ai-projects instrumentor (r3800092642)
You were right, and this changed the fix. Reproduced against azure-ai-projects==2.3.0 + openai==2.53.0 with a mocked transport: with_raw_response.create() returns AsyncStreamWrapper whose stream_async_iter is the still-unparsed LegacyAPIResponse, so my first commit only traded one AttributeError for another:

AttributeError: 'LegacyAPIResponse' object has no attribute '__anext__'

Your point about the test was right too — it patched with_raw_response.create, above the layer that installs the wrapper, so the inner raw response never existed in it.

_open_event_stream() now parses the wrapped raw response and hands it back, keeping the wrapper in the iteration path so telemetry still records. End-to-end against the real package:

raw from with_raw_response : AsyncStreamWrapper
  .stream_async_iter       : LegacyAPIResponse
  _open_event_stream yielded: AsyncStreamWrapper
RESULT: streamed 'Hello world'
telemetry wrapper still in iteration path: True

The test now models that object graph and fails against my previous commit.

Status: upstream issue filed and linked (Azure/azure-sdk-for-python#48646), branch up to date with main, and CI is green on the current head — 35 checks, 23 success / 12 skipped / 0 failed, including the Test Typing Checks job that was previously failing.