fix(router): resolve_llm_passthrough_timeout respects stream_timeout

resolve_llm_passthrough_timeout (added by upstream PR BerriAI#30266) only checked
timeout/request_timeout, so streaming Anthropic /v1/messages calls (routed
through _ageneric_api_call_with_fallbacks) stopped honoring stream_timeout
precedence, unlike the router's own _get_stream_timeout/_get_timeout used by
other call paths. Threads stream and router_stream_timeout through so
streaming requests check stream_timeout first, mirroring existing router
semantics.

Author: tanmaykm

litellm/passthrough/timeout_utils.py

@@ -34,16 +34,29 @@ def resolve_llm_passthrough_timeout(
     kwargs: Optional[dict] = None,
     litellm_params: Optional[dict] = None,
     router_timeout: Optional[float] = None,
+    stream: bool = False,
+    router_stream_timeout: Optional[float] = None,
 ) -> float:
     """
     Resolve upstream httpx timeout for SDK native passthrough (e.g. Bedrock /converse).
 
     Precedence: kwargs timeout/request_timeout -> litellm_params timeout/request_timeout
     -> router_timeout -> general_settings.pass_through_request_timeout -> 600s default.
+
+    For streaming requests, kwargs/litellm_params stream_timeout and router_stream_timeout
+    are checked ahead of the rest of the chain, mirroring Router._get_stream_timeout.
     """
     kwargs = kwargs or {}
     litellm_params = litellm_params or {}
 
+    if stream:
+        for source in (kwargs, litellm_params):
+            val = source.get("stream_timeout")
+            if val is not None:
+                return float(val)
+        if router_stream_timeout is not None:
+            return float(router_stream_timeout)
+
     for source in (kwargs, litellm_params):
         for key in ("timeout", "request_timeout"):
             val = source.get(key)

litellm/router.py

@@ -3036,6 +3036,8 @@ def _update_kwargs_with_deployment(
                 kwargs=kwargs,
                 litellm_params=deployment["litellm_params"],
                 router_timeout=_router_timeout,
+                stream=bool(kwargs.get("stream", False)),
+                router_stream_timeout=self.stream_timeout,
             )
         else:
             kwargs["timeout"] = self._get_timeout(kwargs=kwargs, data=deployment["litellm_params"])

tests/test_litellm/proxy/pass_through_endpoints/test_pass_through_endpoints.py

@@ -974,6 +974,52 @@ def test_resolve_llm_passthrough_timeout_precedence():
         assert resolve_llm_passthrough_timeout() == 6.0
 
 
+def test_resolve_llm_passthrough_timeout_stream_timeout_precedence():
+    # stream_timeout wins over timeout for streaming requests, mirroring Router._get_stream_timeout
+    assert (
+        resolve_llm_passthrough_timeout(
+            kwargs={"stream_timeout": 1, "timeout": 30},
+            stream=True,
+        )
+        == 1.0
+    )
+    # non-streaming requests ignore stream_timeout entirely
+    assert (
+        resolve_llm_passthrough_timeout(
+            kwargs={"stream_timeout": 1, "timeout": 30},
+            stream=False,
+        )
+        == 30.0
+    )
+    # litellm_params stream_timeout is checked when kwargs has none
+    assert (
+        resolve_llm_passthrough_timeout(
+            kwargs={"timeout": 30},
+            litellm_params={"stream_timeout": 2},
+            stream=True,
+        )
+        == 2.0
+    )
+    # router_stream_timeout is a last resort before falling back to the non-stream chain
+    assert (
+        resolve_llm_passthrough_timeout(
+            router_timeout=30,
+            router_stream_timeout=5,
+            stream=True,
+        )
+        == 5.0
+    )
+    # no stream_timeout configured anywhere -> falls back to the non-stream chain
+    assert (
+        resolve_llm_passthrough_timeout(
+            kwargs={"timeout": 30},
+            router_stream_timeout=None,
+            stream=True,
+        )
+        == 30.0
+    )
+
+
 @pytest.mark.asyncio
 async def test_pass_through_request_uses_resolved_timeout():
     with patch("litellm.proxy.proxy_server.proxy_logging_obj") as mock_proxy_logging: