fix(models): preserve the LiteLLM stream error when cleanup also fails

The finally block raised a cleanup failure over any in-flight provider error.
The runner classifies retries from the exception that escapes the model stream,
and _is_network_like_error only recognises APIConnectionError at the top level,
so a masked connection error silently stopped being retryable.

Capture the in-flight error and log the cleanup failure instead of raising it
when the stream has already failed. GeneratorExit from an explicit aclose() is
a close request rather than a stream failure, so it still lets a cleanup error
surface.

Author: SawhneySatvik

src/agents/extensions/models/litellm_model.py

@@ -402,6 +402,7 @@ async def stream_response(
             final_response: Response | None = None
             close_stream_in_background = False
             yielded_terminal_event = False
+            stream_error: Exception | None = None
             try:
                 async for chunk in ChatCmplStreamHandler.handle_stream(
                     response, stream, model=self.model
@@ -415,12 +416,21 @@ async def stream_response(
                 close_stream_in_background = True
                 self._schedule_async_iterator_close(stream)
                 raise
+            except Exception as exc:
+                stream_error = exc
+                raise
             finally:
                 if not close_stream_in_background:
                     try:
                         await self._maybe_aclose(stream)
                     except Exception as exc:
-                        if yielded_terminal_event:
+                        if stream_error is not None:
+                            log_model_action_debug(
+                                logger,
+                                "Ignoring stream cleanup error after stream failure",
+                                exc,
+                            )
+                        elif yielded_terminal_event:
                             log_model_action_debug(
                                 logger,
                                 "Ignoring stream cleanup error after terminal event",

tests/models/test_litellm_chatcompletions_stream.py

@@ -2,7 +2,9 @@
 from collections.abc import AsyncIterator
 from typing import Any, cast
 
+import httpx
 import pytest
+from openai import APIConnectionError
 from openai.types.chat.chat_completion_chunk import (
     ChatCompletionChunk,
     Choice,
@@ -928,6 +930,34 @@ async def test_stream_response_ignores_close_error_after_terminal_event(monkeypa
     assert output_events[-1].type == "response.completed"
 
 
+@pytest.mark.allow_call_model_methods
+@pytest.mark.asyncio
+async def test_stream_response_preserves_stream_error_when_close_also_fails(monkeypatch) -> None:
+    """A failing cleanup must not replace the in-flight provider error.
+
+    The runner classifies retries from the exception that escapes the model stream, so a
+    retryable provider error has to survive a cleanup failure.
+    """
+
+    class _FailingStream(_ClosableChatStream):
+        async def __anext__(self) -> ChatCompletionChunk:
+            raise APIConnectionError(request=httpx.Request("POST", "https://example.test/v1"))
+
+        async def aclose(self) -> None:
+            self.aclose_calls += 1
+            raise RuntimeError("provider close failed")
+
+    provider_stream = _FailingStream([])
+    _patch_fetch_response(monkeypatch, provider_stream)
+    model = LitellmProvider().get_model("gpt-4")
+
+    with pytest.raises(APIConnectionError):
+        async for _event in _stream_response(model):
+            pass
+
+    assert provider_stream.aclose_calls == 1
+
+
 @pytest.mark.allow_call_model_methods
 @pytest.mark.asyncio
 async def test_stream_response_surfaces_close_error_before_terminal_event(monkeypatch) -> None: