feat(http-client-python): structured JSONL/SSE streaming for both azure and unbranded flavors

Make the vendored Stream/AsyncStream runtime flavor-aware: the functional
import and the docstrings in streaming_base.py now use
{{ code_model.core_library }}.rest, so the unbranded flavor targets
corehttp.rest instead of a hardcoded azure.core.rest (azure flavor output
is unchanged). Update the shared JSONL mock tests to consume Stream[Info]
(sync + async), and refresh the README and changelog to state that both
flavors emit structured streaming. The terminal_event extension and the
builder_serializer generated call site are preserved.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 51359cbf-bc53-429e-b947-8284a91d7d46

Author: l0lawrence

.chronus/changes/structured-streaming-2026-0-0.md

@@ -4,9 +4,17 @@ packages:
   - "@typespec/http-client-python"
 ---
 
-Generate structured streaming client methods for the **Azure flavor**: operations whose HTTP response is a JSONL (`application/jsonl`) or SSE (`text/event-stream`) stream now return `Stream[T]` / `AsyncStream[T]`, yielding deserialized model instances instead of raw bytes.
+Generate structured streaming client methods: operations whose HTTP response is a JSONL (`application/jsonl`) or SSE (`text/event-stream`) stream now return `Stream[T]` / `AsyncStream[T]`, yielding deserialized model instances instead of raw bytes.
 
-`Stream` and `AsyncStream` are available from the generated package's base namespace. Their runtime (plus the JSONL / SSE decoders) is vendored at `_utils/streaming_base.py`, so it depends only on the released `azure.core.rest`.
+`Stream` and `AsyncStream` are available from the generated package's base namespace. Their runtime (plus the JSONL / SSE decoders) is vendored at `_utils/streaming_base.py` and depends only on the released core runtime for the flavor — `azure.core.rest` for the Azure flavor and `corehttp.rest` for the unbranded flavor.
+
+```python
+from your_sdk import Stream
+
+stream: Stream[Thing] = client.receive()
+for thing in stream:
+    ...
+```
 
 ```python
 from your_sdk import Stream

packages/http-client-python/README.md

@@ -156,7 +156,7 @@ Emit YAML code model only, without running Python generator. For batch processin
 
 ## Structured streaming (JSONL / SSE)
 
-For the **Azure flavor**, operations whose HTTP response is a JSONL (`application/jsonl`) or SSE (`text/event-stream`) stream generate client methods that return `Stream[T]` (sync) / `AsyncStream[T]` (async), yielding deserialized model instances instead of raw bytes. This is driven by the TCGC response stream metadata (the response stream type) — there is no opt-in emitter option. For the unbranded flavor, streaming responses keep the existing raw byte-iterator behavior (`Iterator[bytes]` / `AsyncIterator[bytes]`).
+Operations whose HTTP response is a JSONL (`application/jsonl`) or SSE (`text/event-stream`) stream generate client methods that return `Stream[T]` (sync) / `AsyncStream[T]` (async), yielding deserialized model instances instead of raw bytes. This is driven by the TCGC response stream metadata (the response stream type) — there is no opt-in emitter option. This applies to both the Azure and unbranded flavors.
 
 For an operation returning `JsonlStream<Thing>`, the generated method returns `Stream[Thing]` (sync) / `AsyncStream[Thing]` (async), yielding deserialized `Thing` instances as each JSONL line arrives. Similarly, `SSEStream<Events>` produces a `Stream` / `AsyncStream` over the SSE event payloads.
 
@@ -171,6 +171,6 @@ for thing in stream:
     ...
 ```
 
-The `Stream` / `AsyncStream` runtime (plus the JSONL and SSE decoders) is **vendored** into the generated package at `_utils/streaming_base.py` (alongside `_utils/model_base.py`). It depends only on the released `azure.core.rest`, so no unreleased `azure.core.streaming` dependency is required at runtime.
+The `Stream` / `AsyncStream` runtime (plus the JSONL and SSE decoders) is **vendored** into the generated package at `_utils/streaming_base.py` (alongside `_utils/model_base.py`). It depends only on the released core runtime for the flavor — `azure.core.rest` for the Azure flavor and `corehttp.rest` for the unbranded flavor — so no unreleased `azure.core.streaming` dependency is required at runtime.
 
 SSE `@events` unions use TCGC event metadata to deserialize each named event into its corresponding generated model. Events marked with `@terminalEvent` stop iteration without being yielded.

packages/http-client-python/generator/pygen/codegen/templates/streaming_base.py.jinja2

@@ -7,8 +7,8 @@
 # This file is vendored from azure-core (azure.core.streaming). It provides the
 # Stream / AsyncStream helpers (plus the JSONL / SSE decoders and event types)
 # used by generated structured-streaming operations, so the generated package
-# does not take a hard dependency on an azure-core version that ships
-# azure.core.streaming. Do not edit by hand.
+# does not take a hard dependency on a core runtime that ships the streaming
+# helpers. Do not edit by hand.
 # --------------------------------------------------------------------------
 import codecs
 import json
@@ -32,7 +32,7 @@ from typing import (
 
 from typing_extensions import Self
 
-from azure.core.rest import AsyncHttpResponse, HttpResponse
+from {{ code_model.core_library }}.rest import AsyncHttpResponse, HttpResponse
 
 DecodedType = TypeVar("DecodedType")
 ReturnType_co = TypeVar("ReturnType_co", covariant=True)
@@ -544,13 +544,13 @@ class Stream(Iterator[ReturnType_co]):
     """Stream class for consuming a decoded event stream (e.g. JSONL or SSE).
 
     :keyword response: The response object.
-    :paramtype response: ~azure.core.rest.HttpResponse
+    :paramtype response: ~{{ code_model.core_library }}.rest.HttpResponse
     :keyword decoder: A decoder to use for the stream. If omitted, the decoder is
         inferred from the response ``Content-Type`` header.
     :paramtype decoder: StreamDecoder
     :keyword deserialization_callback: A callback that takes the response and the decoded event and
         returns a deserialized object.
-    :paramtype deserialization_callback: Callable[[~azure.core.rest.HttpResponse, Any], ReturnType]
+    :paramtype deserialization_callback: Callable[[~{{ code_model.core_library }}.rest.HttpResponse, Any], ReturnType]
     :keyword terminal_event: Optional event ``data`` value that terminates the stream (e.g.
         ``"[DONE]"``). When an event's ``data`` equals this value, iteration stops and the
         event is not passed to ``deserialization_callback``.
@@ -612,13 +612,13 @@ class AsyncStream(AsyncIterator[ReturnType_co]):
     """AsyncStream class for asynchronously consuming a decoded event stream (e.g. JSONL or SSE).
 
     :keyword response: The response object.
-    :paramtype response: ~azure.core.rest.AsyncHttpResponse
+    :paramtype response: ~{{ code_model.core_library }}.rest.AsyncHttpResponse
     :keyword decoder: A decoder to use for the stream. If omitted, the decoder is
         inferred from the response ``Content-Type`` header.
     :paramtype decoder: AsyncStreamDecoder
     :keyword deserialization_callback: A callback that takes the response and the decoded event and
         returns a deserialized object.
-    :paramtype deserialization_callback: Callable[[~azure.core.rest.AsyncHttpResponse, Any], ReturnType]
+    :paramtype deserialization_callback: Callable[[~{{ code_model.core_library }}.rest.AsyncHttpResponse, Any], ReturnType]
     :keyword terminal_event: Optional event ``data`` value that terminates the stream (e.g.
         ``"[DONE]"``). When an event's ``data`` equals this value, iteration stops and the
         event is not passed to ``deserialization_callback``.

packages/http-client-python/tests/mock_api/shared/asynctests/test_streaming_jsonl_async.py

@@ -25,4 +25,5 @@ async def test_basic_send(client: JsonlClient):
 
 @pytest.mark.asyncio
 async def test_basic_recv(client: JsonlClient):
-    assert b"".join([d async for d in (await client.basic.receive())]) == JSONL
+    stream = await client.basic.receive()
+    assert [item.desc async for item in stream] == ["one", "two", "three"]

packages/http-client-python/tests/mock_api/shared/test_streaming_jsonl.py

@@ -22,4 +22,4 @@ def test_basic_send(client: JsonlClient):
 
 
 def test_basic_recv(client: JsonlClient):
-    assert b"".join(client.basic.receive()) == JSONL
+    assert [item.desc for item in client.basic.receive()] == ["one", "two", "three"]