if shared_aiohttp_session is not None and not shared_aiohttp_session.closed:
    data["shared_session"] = shared_aiohttp_session  # reuse pooled connection
else:
    logger.info("SESSION REUSE: No shared session available for this request")
    # ↑ falls back permanently — session is never recreated

Once shared_aiohttp_session.closed == True, no code path recreates it.
The proxy_server creates the session once at startup and never again:

# proxy_server.py — created once, never recreated
shared_aiohttp_session = await _initialize_shared_aiohttp_session()
# limit=300 total connections, limit_per_host=50, keepalive_timeout=120s

Evidence (pod logs)

Full session lifecycle visible on a 3-hour-old pod (Vertex AI backend):

✓ SESSION REUSE: Created shared aiohttp session (ID: 139414346342688, limit=300, limit_per_host=50)
✓ SESSION REUSE: Attached shared aiohttp session to request (ID: 139414346342688)
✓ SESSION REUSE: Attached shared aiohttp session to request (ID: 139414346342688)
✗ SESSION REUSE: No shared session available for this request   ← session died, never recovered
✗ SESSION REUSE: No shared session available for this request

Expected behavior

When the session is found closed, the proxy should recreate it:

if shared_aiohttp_session is None or shared_aiohttp_session.closed:
    logger.warning("SESSION REUSE: Session closed, recreating...")
    shared_aiohttp_session = await _initialize_shared_aiohttp_session()
data["shared_session"] = shared_aiohttp_session

Environment

- LiteLLM version: 1.81.12
- Backend: Vertex AI
- Deployment: Kubernetes (pod-based), multiple replicas

Are you an ML Ops team?

Yes



### Steps to Reproduce

## Steps to Reproduce

### Actual scenario (production trigger)

These are the exact conditions that caused the session to close in staging
(GKE, LiteLLM v1.81.12, Vertex AI backend):

1. Run LiteLLM proxy with `shared_aiohttp_session` enabled (default).
   Confirm session is created at startup:
   SESSION REUSE: Created shared aiohttp session (ID: ..., limit=300, limit_per_host=50)
2. Allow a Redis Sentinel failover to occur (or simulate Redis unavailability).
This causes `async_increment()` / `update_spend` to block on every write.
3. Observe background jobs (`update_spend` every 12s, `ProxyConfig.add_deployment`
every 30s) begin to overlap and stall:
   Execution of job skipped: maximum number of running instances reached (1)
4. With the async event loop saturated by stalled coroutines, the aiohttp
`TCPConnector` fails to service keepalive pings within `keepalive_timeout=120s`.
The connector closes, setting `shared_aiohttp_session.closed = True`.
5. All subsequent requests permanently fall back to per-request HTTPS connections:
   SESSION REUSE: No shared session available for this request  ← repeats forever
6. Pod CPU climbs to ~980m and stays there. `/health/readiness` begins timing out.
**The only recovery is a pod restart** — the session is never recreated in-process.

---

### Minimal reproduction (for contributors — no Redis required)

This reproduces the no-recovery behavior directly, without needing the full
Redis/event-loop cascade:

```python
import asyncio
import litellm.proxy.proxy_server as proxy_server
from litellm.proxy.route_llm_request import add_shared_session_to_data

async def main():
 # 1. Simulate startup
 proxy_server.shared_aiohttp_session = await proxy_server._initialize_shared_aiohttp_session()
 print("Session open:", not proxy_server.shared_aiohttp_session.closed)  # True

 # 2. Force-close the session (simulates event loop pressure / keepalive timeout)
 await proxy_server.shared_aiohttp_session.close()
 print("Session closed:", proxy_server.shared_aiohttp_session.closed)    # True

 # 3. Simulate an incoming request — expect: session stays dead, no recovery
 data = {}
 add_shared_session_to_data(data)  # currently sync
 print("shared_session in data:", "shared_session" in data)              # False (bug)
 print("Session still closed:", proxy_server.shared_aiohttp_session.closed)  # True (bug)

asyncio.run(main())

Expected after fix:
shared_session in data: True       ← session was auto-recreated
Session still closed: False

Actual (current behavior):
SESSION REUSE: No shared session available for this request   ← logged every request
shared_session in data: False      ← falls back to per-request HTTPS forever
Session still closed: True         ← never recovered

### Relevant log output

```shell