From 0b69c21ecab3866152db91608aff65fdcf2356a9 Mon Sep 17 00:00:00 2001 From: Ishaan Jaffer Date: Sat, 21 Feb 2026 12:27:46 -0800 Subject: [PATCH] Revert "fix(http_handler): bypass cache when shared_session is provided for aiohttp tracing (#20630)" This reverts commit 7ee36c2a3ab74f01543033cc5a32fbaba0863c26. --- litellm/llms/custom_httpx/http_handler.py | 23 +----- .../llms/custom_httpx/test_http_handler.py | 79 ------------------- 2 files changed, 2 insertions(+), 100 deletions(-) diff --git a/litellm/llms/custom_httpx/http_handler.py b/litellm/llms/custom_httpx/http_handler.py index 328097639e5..3789f546d73 100644 --- a/litellm/llms/custom_httpx/http_handler.py +++ b/litellm/llms/custom_httpx/http_handler.py @@ -1207,28 +1207,7 @@ def get_async_httpx_client( If not present, creates a new client Caches the new client and returns it. - - Note: When shared_session is provided, the cache is bypassed to ensure - the user's session (with its trace_configs, connector settings, etc.) - is used for the request. """ - # When shared_session is provided, bypass cache and create a new handler - # that uses the user's session directly. This preserves the user's - # session configuration including trace_configs for aiohttp tracing. - if shared_session is not None: - verbose_logger.debug( - f"shared_session provided (ID: {id(shared_session)}), bypassing client cache" - ) - if params is not None: - handler_params = {k: v for k, v in params.items() if k != "disable_aiohttp_transport"} - handler_params["shared_session"] = shared_session - return AsyncHTTPHandler(**handler_params) - else: - return AsyncHTTPHandler( - timeout=httpx.Timeout(timeout=600.0, connect=5.0), - shared_session=shared_session, - ) - _params_key_name = "" if params is not None: for key, value in params.items(): @@ -1255,10 +1234,12 @@ def get_async_httpx_client( if params is not None: # Filter out params that are only used for cache key, not for AsyncHTTPHandler.__init__ handler_params = {k: v for k, v in params.items() if k != "disable_aiohttp_transport"} + handler_params["shared_session"] = shared_session _new_client = AsyncHTTPHandler(**handler_params) else: _new_client = AsyncHTTPHandler( timeout=httpx.Timeout(timeout=600.0, connect=5.0), + shared_session=shared_session, ) cache.set_cache( diff --git a/tests/test_litellm/llms/custom_httpx/test_http_handler.py b/tests/test_litellm/llms/custom_httpx/test_http_handler.py index caf90dce6c8..f3b76ddbe82 100644 --- a/tests/test_litellm/llms/custom_httpx/test_http_handler.py +++ b/tests/test_litellm/llms/custom_httpx/test_http_handler.py @@ -483,85 +483,6 @@ async def test_session_reuse_integration(): await client2.close() -@pytest.mark.asyncio -async def test_shared_session_bypasses_cache(): - """ - Test that when shared_session is provided, the cache is bypassed. - - This is critical for aiohttp tracing support - users need their custom - ClientSession (with trace_configs) to be used, not a cached session. - - Related: GitHub issue #20174 - """ - from litellm.llms.custom_httpx.http_handler import get_async_httpx_client - from litellm.types.utils import LlmProviders - - # First, get a cached client without shared_session - cached_client = get_async_httpx_client( - llm_provider=LlmProviders.ANTHROPIC, - shared_session=None - ) - - # Now create a mock shared session - mock_session = MockClientSession() - - # Get a client WITH shared_session - this should NOT return the cached client - client_with_session = get_async_httpx_client( - llm_provider=LlmProviders.ANTHROPIC, # Same provider! - shared_session=mock_session # type: ignore - ) - - # The clients should be DIFFERENT - cache should be bypassed when shared_session is provided - assert client_with_session is not cached_client, \ - "Cache should be bypassed when shared_session is provided" - - # Verify the shared_session handler is using our mock session - # The transport should have our mock_session as its client - transport = client_with_session.client._transport - if hasattr(transport, 'client'): - assert transport.client is mock_session, \ - "Handler should use the provided shared_session" - - # Clean up - await cached_client.close() - await client_with_session.close() - - -@pytest.mark.asyncio -async def test_shared_session_each_call_gets_new_handler(): - """ - Test that each call with shared_session creates a new handler. - - This ensures user sessions (with their trace_configs, etc.) are always - used and not affected by caching. - """ - from litellm.llms.custom_httpx.http_handler import get_async_httpx_client - from litellm.types.utils import LlmProviders - - # Create two different mock sessions - mock_session1 = MockClientSession() - mock_session2 = MockClientSession() - - # Get clients with different sessions for the same provider - client1 = get_async_httpx_client( - llm_provider=LlmProviders.ANTHROPIC, - shared_session=mock_session1 # type: ignore - ) - - client2 = get_async_httpx_client( - llm_provider=LlmProviders.ANTHROPIC, # Same provider - shared_session=mock_session2 # type: ignore # Different session - ) - - # Should be different clients, each using their own session - assert client1 is not client2, \ - "Different shared_sessions should create different handlers" - - # Clean up - await client1.close() - await client2.close() - - @pytest.mark.asyncio async def test_session_validation(): """Test that session validation works correctly"""