feat: implement multi-route inference proxy support

- Proto: add InferenceModelEntry message with alias/provider/model fields;
  add repeated models field to ClusterInferenceConfig, Set/Get request/response
- Server: add upsert_multi_model_route() for storing multiple model entries
  under a single route slot; update resolve_route_by_name() to expand
  multi-model configs into per-alias ResolvedRoute entries
- Router: add select_route() with alias-first, protocol-fallback strategy;
  add model_hint parameter to proxy_with_candidates() variants
- Sandbox proxy: extract model field from JSON body as routing hint
- Tests: 7 new tests covering select_route, multi-model resolution, and
  bundle expansion; all 291 existing tests continue to pass

Signed-off-by: Lyle Hopkins <lyle@cosmicnetworks.com>

Author: cosmicnet

crates/openshell-router/src/lib.rs

@@ -36,6 +36,28 @@ pub struct Router {
     client: reqwest::Client,
 }
 
+/// Select a route from `candidates` using alias-first, protocol-fallback strategy.
+///
+/// 1. If `model_hint` is provided, find a candidate whose `name` matches the hint
+///    **and** whose protocols include `protocol`.
+/// 2. Otherwise, return the first candidate whose protocols contain `protocol`.
+fn select_route<'a>(
+    candidates: &'a [ResolvedRoute],
+    protocol: &str,
+    model_hint: Option<&str>,
+) -> Option<&'a ResolvedRoute> {
+    if let Some(hint) = model_hint {
+        if let Some(r) = candidates.iter().find(|r| {
+            r.name == hint && r.protocols.iter().any(|p| p == protocol)
+        }) {
+            return Some(r);
+        }
+    }
+    candidates
+        .iter()
+        .find(|r| r.protocols.iter().any(|p| p == protocol))
+}
+
 impl Router {
     pub fn new() -> Result<Self, RouterError> {
         let client = reqwest::Client::builder()
@@ -57,8 +79,10 @@ impl Router {
 
     /// Proxy a raw HTTP request to the first compatible route from `candidates`.
     ///
-    /// Filters candidates by `source_protocol` compatibility (exact match against
-    /// one of the route's `protocols`), then forwards to the first match.
+    /// When `model_hint` is provided, the router first looks for a candidate whose
+    /// `name` (alias) matches the hint.  If no alias matches, it falls back to
+    /// protocol-based selection (first candidate whose `protocols` list contains
+    /// `source_protocol`).
     pub async fn proxy_with_candidates(
         &self,
         source_protocol: &str,
@@ -67,11 +91,10 @@ impl Router {
         headers: Vec<(String, String)>,
         body: bytes::Bytes,
         candidates: &[ResolvedRoute],
+        model_hint: Option<&str>,
     ) -> Result<ProxyResponse, RouterError> {
         let normalized_source = source_protocol.trim().to_ascii_lowercase();
-        let route = candidates
-            .iter()
-            .find(|r| r.protocols.iter().any(|p| p == &normalized_source))
+        let route = select_route(candidates, &normalized_source, model_hint)
             .ok_or_else(|| RouterError::NoCompatibleRoute(source_protocol.to_string()))?;
 
         info!(
@@ -111,11 +134,10 @@ impl Router {
         headers: Vec<(String, String)>,
         body: bytes::Bytes,
         candidates: &[ResolvedRoute],
+        model_hint: Option<&str>,
     ) -> Result<StreamingProxyResponse, RouterError> {
         let normalized_source = source_protocol.trim().to_ascii_lowercase();
-        let route = candidates
-            .iter()
-            .find(|r| r.protocols.iter().any(|p| p == &normalized_source))
+        let route = select_route(candidates, &normalized_source, model_hint)
             .ok_or_else(|| RouterError::NoCompatibleRoute(source_protocol.to_string()))?;
 
         info!(
@@ -187,4 +209,57 @@ mod tests {
         let err = Router::from_config(&config).unwrap_err();
         assert!(matches!(err, RouterError::Internal(_)));
     }
+
+    fn make_route(name: &str, protocols: Vec<&str>) -> ResolvedRoute {
+        ResolvedRoute {
+            name: name.to_string(),
+            endpoint: "http://localhost".to_string(),
+            model: format!("{name}-model"),
+            api_key: "key".to_string(),
+            protocols: protocols.into_iter().map(String::from).collect(),
+            auth: config::AuthHeader::Bearer,
+            default_headers: Vec::new(),
+        }
+    }
+
+    #[test]
+    fn select_route_protocol_fallback_when_no_hint() {
+        let routes = vec![
+            make_route("ollama-local", vec!["openai_chat_completions"]),
+            make_route("anthropic-prod", vec!["anthropic_messages"]),
+        ];
+        let r = select_route(&routes, "anthropic_messages", None).unwrap();
+        assert_eq!(r.name, "anthropic-prod");
+    }
+
+    #[test]
+    fn select_route_alias_match_takes_priority() {
+        let routes = vec![
+            make_route("ollama-local", vec!["openai_chat_completions"]),
+            make_route("openai-prod", vec!["openai_chat_completions", "openai_responses"]),
+        ];
+        // Both support openai_chat_completions, but hint selects the second one.
+        let r = select_route(&routes, "openai_chat_completions", Some("openai-prod")).unwrap();
+        assert_eq!(r.name, "openai-prod");
+    }
+
+    #[test]
+    fn select_route_alias_must_also_match_protocol() {
+        let routes = vec![
+            make_route("ollama-local", vec!["openai_chat_completions"]),
+            make_route("anthropic-prod", vec!["anthropic_messages"]),
+        ];
+        // Hint says "anthropic-prod" but protocol is openai_chat_completions — can't use it.
+        // Falls back to protocol match → ollama-local.
+        let r = select_route(&routes, "openai_chat_completions", Some("anthropic-prod")).unwrap();
+        assert_eq!(r.name, "ollama-local");
+    }
+
+    #[test]
+    fn select_route_no_match_returns_none() {
+        let routes = vec![
+            make_route("ollama-local", vec!["openai_chat_completions"]),
+        ];
+        assert!(select_route(&routes, "anthropic_messages", None).is_none());
+    }
 }

crates/openshell-router/tests/backend_integration.rs

@@ -66,6 +66,7 @@ async fn proxy_forwards_request_to_backend() {
             vec![("content-type".to_string(), "application/json".to_string())],
             bytes::Bytes::from(body),
             &candidates,
+            None,
         )
         .await
         .unwrap();
@@ -98,6 +99,7 @@ async fn proxy_upstream_401_returns_error() {
             vec![],
             bytes::Bytes::new(),
             &candidates,
+            None,
         )
         .await
         .unwrap();
@@ -127,6 +129,7 @@ async fn proxy_no_compatible_route_returns_error() {
             vec![],
             bytes::Bytes::new(),
             &candidates,
+            None,
         )
         .await
         .unwrap_err();
@@ -160,6 +163,7 @@ async fn proxy_strips_auth_header() {
             vec![("authorization".to_string(), "Bearer client-key".to_string())],
             bytes::Bytes::new(),
             &candidates,
+            None,
         )
         .await
         .unwrap();
@@ -194,6 +198,7 @@ async fn proxy_mock_route_returns_canned_response() {
             vec![("content-type".to_string(), "application/json".to_string())],
             bytes::Bytes::from(body),
             &candidates,
+            None,
         )
         .await
         .unwrap();
@@ -239,6 +244,7 @@ async fn proxy_overrides_model_in_request_body() {
             vec![("content-type".to_string(), "application/json".to_string())],
             bytes::Bytes::from(body),
             &candidates,
+            None,
         )
         .await
         .unwrap();
@@ -277,6 +283,7 @@ async fn proxy_inserts_model_when_absent_from_body() {
             vec![("content-type".to_string(), "application/json".to_string())],
             bytes::Bytes::from(body),
             &candidates,
+            None,
         )
         .await
         .unwrap();
@@ -332,6 +339,7 @@ async fn proxy_uses_x_api_key_for_anthropic_route() {
             ],
             bytes::Bytes::from(body),
             &candidates,
+            None,
         )
         .await
         .unwrap();
@@ -380,6 +388,7 @@ async fn proxy_anthropic_does_not_send_bearer_auth() {
             vec![("content-type".to_string(), "application/json".to_string())],
             bytes::Bytes::from(b"{}".to_vec()),
             &candidates,
+            None,
         )
         .await
         .unwrap();
@@ -436,6 +445,7 @@ async fn proxy_forwards_client_anthropic_version_header() {
             ],
             bytes::Bytes::from(body),
             &candidates,
+            None,
         )
         .await
         .unwrap();

crates/openshell-sandbox/src/proxy.rs

@@ -105,7 +105,7 @@ impl InferenceContext {
     ) -> Result<openshell_router::ProxyResponse, openshell_router::RouterError> {
         let routes = self.system_routes.read().await;
         self.router
-            .proxy_with_candidates(protocol, method, path, headers, body, &routes)
+            .proxy_with_candidates(protocol, method, path, headers, body, &routes, None)
             .await
     }
 }
@@ -993,6 +993,12 @@ async fn route_inference_request(
             return Ok(true);
         }
 
+        // Extract the model field from the JSON body as a routing hint.
+        // If parsing fails or model is absent, we fall back to protocol-only matching.
+        let model_hint = serde_json::from_slice::<serde_json::Value>(&request.body)
+            .ok()
+            .and_then(|v| v.get("model")?.as_str().map(String::from));
+
         match ctx
             .router
             .proxy_with_candidates_streaming(
@@ -1002,6 +1008,7 @@ async fn route_inference_request(
                 filtered_headers,
                 bytes::Bytes::from(request.body.clone()),
                 &routes,
+                model_hint.as_deref(),
             )
             .await
         {