refactor: hoist STREAMING_BODY_MARKER + _STREAMING_BODY_REFUSAL_NOTE to module constants

Final-review feedback: the "httpware.streaming_body" marker key was
duplicated at 5 sites (1 write in client.py + 4 reads in retry.py) and
the PEP-678 refusal note was duplicated at 4 sites in retry.py. Per
project convention (module-level UPPER_CASE constants over inlined
string literals; same pattern as _MAX_ATTEMPTS_INVALID,
_MAX_CONCURRENT_INVALID, _DEFAULT_DECODER_MISSING_MESSAGE), hoist both:

- STREAMING_BODY_MARKER in client.py (public so retry.py can import it;
  this IS the contract between the two modules)
- _STREAMING_BODY_REFUSAL_NOTE in retry.py (private; only used there)

retry.py now imports STREAMING_BODY_MARKER from client. No circular
import: client doesn't import retry transitively.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: lesnik512

src/httpware/client.py

@@ -71,6 +71,13 @@ def _raise_on_status_error(response: httpx2.Response) -> None:
         raise exc_class(response)
 
 
+STREAMING_BODY_MARKER = "httpware.streaming_body"
+"""Key set on ``httpx2.Request.extensions`` by ``_request_with_body`` when content/data/files is an async-iterable.
+
+``Retry.__call__`` reads this marker to refuse retrying a streamed-body request
+(the consumed iterator cannot replay across attempts)."""
+
+
 def _is_streaming_body(value: typing.Any) -> bool:
     """Return True if value is an async-iterable that cannot be safely replayed for retry."""
     if value is None:
@@ -210,7 +217,7 @@ async def _request_with_body(  # noqa: PLR0913, C901 — mirrors httpx2 per-meth
             kwargs["files"] = files
         request = self._httpx2_client.build_request(method, url, **kwargs)
         if _is_streaming_body(content) or _is_streaming_body(data) or _is_streaming_body(files):
-            request.extensions["httpware.streaming_body"] = True
+            request.extensions[STREAMING_BODY_MARKER] = True
         return await self.send(request, response_model=response_model)
 
     @typing.overload

src/httpware/middleware/resilience/retry.py

@@ -16,6 +16,7 @@
 
 import httpx2
 
+from httpware.client import STREAMING_BODY_MARKER
 from httpware.errors import NetworkError, RetryBudgetExhaustedError, StatusError, TimeoutError  # noqa: A004
 from httpware.middleware import Next
 from httpware.middleware.resilience._backoff import full_jitter_delay
@@ -43,6 +44,7 @@
 )
 
 _MAX_ATTEMPTS_INVALID = "max_attempts must be >= 1"
+_STREAMING_BODY_REFUSAL_NOTE = "httpware: not retrying — request body is a stream that cannot replay across attempts"
 
 
 def _parse_retry_after(value: str) -> float | None:
@@ -108,42 +110,34 @@ async def __call__(self, request: httpx2.Request, next: Next) -> httpx2.Response
             except StatusError as exc:
                 retryable_status = exc.response.status_code in self.retry_status_codes
                 if not method_eligible or not retryable_status:
-                    if retryable_status and request.extensions.get("httpware.streaming_body"):
-                        exc.add_note(
-                            "httpware: not retrying — request body is a stream that cannot replay across attempts"
-                        )
+                    if retryable_status and request.extensions.get(STREAMING_BODY_MARKER):
+                        exc.add_note(_STREAMING_BODY_REFUSAL_NOTE)
                     raise
                 last_exc = exc
                 last_response = exc.response
             except (NetworkError, TimeoutError) as exc:
                 if not method_eligible:
-                    if request.extensions.get("httpware.streaming_body"):
-                        exc.add_note(
-                            "httpware: not retrying — request body is a stream that cannot replay across attempts"
-                        )
+                    if request.extensions.get(STREAMING_BODY_MARKER):
+                        exc.add_note(_STREAMING_BODY_REFUSAL_NOTE)
                     raise
                 last_exc = exc
                 last_response = None
             except builtins.TimeoutError as exc:
                 wrapped = TimeoutError("attempt timed out")
                 wrapped.__cause__ = exc  # set now; the retry path (last_exc = wrapped) has no `from` clause
                 if not method_eligible:
-                    if request.extensions.get("httpware.streaming_body"):
-                        wrapped.add_note(
-                            "httpware: not retrying — request body is a stream that cannot replay across attempts"
-                        )
+                    if request.extensions.get(STREAMING_BODY_MARKER):
+                        wrapped.add_note(_STREAMING_BODY_REFUSAL_NOTE)
                     raise wrapped from exc
                 last_exc = wrapped
                 last_response = None
 
             # ---- retryable failure path
-            if request.extensions.get("httpware.streaming_body"):
+            if request.extensions.get(STREAMING_BODY_MARKER):
                 if last_exc is None:  # pragma: no cover — invariant from except branch
                     msg = "Retry: streaming-body refusal reached with no last_exc"
                     raise AssertionError(msg)
-                last_exc.add_note(
-                    "httpware: not retrying — request body is a stream that cannot replay across attempts"
-                )
+                last_exc.add_note(_STREAMING_BODY_REFUSAL_NOTE)
                 raise last_exc
 
             if is_last: