Redis-backed session cache for cross-replica model affinity (#879)

* add pluggable session cache with Redis backend

* add Redis session affinity demos (Docker Compose and Kubernetes)

* address PR review feedback on session cache

* document Redis session cache backend for model affinity

* sync rendered config reference with session_cache addition

* add tenant-scoped Redis session cache keys and remove dead log_affinity_hit

- Add tenant_header to SessionCacheConfig; when set, cache keys are scoped
  as plano:affinity:{tenant_id}:{session_id} for multi-tenant isolation
- Thread tenant_id through RouterService, routing_service, and llm handlers
- Use Cow<'_, str> in session_key to avoid allocation when no tenant is set
- Remove unused log_affinity_hit (logging was already inlined at call sites)

* remove session_affinity_redis and session_affinity_redis_k8s demos

crates/brightstaff/src/handlers/llm/mod.rs

@@ -99,10 +99,16 @@ async fn llm_chat_inner(
         .get(MODEL_AFFINITY_HEADER)
         .and_then(|h| h.to_str().ok())
         .map(|s| s.to_string());
+    let tenant_id: Option<String> = state
+        .router_service
+        .tenant_header()
+        .and_then(|hdr| request_headers.get(hdr))
+        .and_then(|v| v.to_str().ok())
+        .map(|s| s.to_string());
     let pinned_model: Option<String> = if let Some(ref sid) = session_id {
         state
             .router_service
-            .get_cached_route(sid)
+            .get_cached_route(sid, tenant_id.as_deref())
             .await
             .map(|c| c.model_name)
     } else {
@@ -313,7 +319,7 @@ async fn llm_chat_inner(
         if let Some(ref sid) = session_id {
             state
                 .router_service
-                .cache_route(sid.clone(), model.clone(), route_name)
+                .cache_route(sid.clone(), tenant_id.as_deref(), model.clone(), route_name)
                 .await;
         }
 

crates/brightstaff/src/handlers/routing_service.rs

@@ -76,6 +76,12 @@ pub async fn routing_decision(
         .and_then(|h| h.to_str().ok())
         .map(|s| s.to_string());
 
+    let tenant_id: Option<String> = router_service
+        .tenant_header()
+        .and_then(|hdr| request_headers.get(hdr))
+        .and_then(|v| v.to_str().ok())
+        .map(|s| s.to_string());
+
     let custom_attrs = collect_custom_trace_attributes(&request_headers, span_attributes.as_ref());
 
     let request_span = info_span!(
@@ -94,11 +100,13 @@ pub async fn routing_decision(
         request_headers,
         custom_attrs,
         session_id,
+        tenant_id,
     )
     .instrument(request_span)
     .await
 }
 
+#[allow(clippy::too_many_arguments)]
 async fn routing_decision_inner(
     request: Request<hyper::body::Incoming>,
     router_service: Arc<RouterService>,
@@ -107,6 +115,7 @@ async fn routing_decision_inner(
     request_headers: hyper::HeaderMap,
     custom_attrs: std::collections::HashMap<String, String>,
     session_id: Option<String>,
+    tenant_id: Option<String>,
 ) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
     set_service_name(operation_component::ROUTING);
     opentelemetry::trace::get_active_span(|span| {
@@ -126,7 +135,10 @@ async fn routing_decision_inner(
 
     // Session pinning: check cache before doing any routing work
     if let Some(ref sid) = session_id {
-        if let Some(cached) = router_service.get_cached_route(sid).await {
+        if let Some(cached) = router_service
+            .get_cached_route(sid, tenant_id.as_deref())
+            .await
+        {
             info!(
                 session_id = %sid,
                 model = %cached.model_name,
@@ -206,6 +218,7 @@ async fn routing_decision_inner(
                 router_service
                     .cache_route(
                         sid.clone(),
+                        tenant_id.as_deref(),
                         result.model_name.clone(),
                         result.route_name.clone(),
                     )