fix(router): match model hint against route model ID in multi-model selection

When multiple routes share the same protocol (e.g. openai_responses),
select_route() only matched the model hint from the request body against
route aliases (names). If an agent sent the actual model ID (e.g.
"gpt-5.4") instead of the alias ("openai-codex"), the alias lookup
missed and the router fell back to the first protocol-compatible route,
which could be a completely different provider.

Add a second lookup pass that matches the hint against route.model before
falling back to blind protocol selection. Priority order:

  1. Alias match (route name == hint) — existing behavior
  2. Model ID match (route model == hint) — new
  3. First protocol-compatible route — existing fallback

Also add strip_version_prefix field to InferenceApiPattern so the codex
pattern (/v1/codex/*) can strip the /v1 proxy artifact before forwarding,
allowing backends whose base URL omits /v1 to receive the correct path.

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

Author: cosmicnet

crates/openshell-router/src/lib.rs

@@ -34,25 +34,37 @@ pub struct Router {
     client: reqwest::Client,
 }
 
-/// Select a route from `candidates` using alias-first, protocol-fallback strategy.
+/// Select a route from `candidates` using alias-first, model-second,
+/// 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`.
+/// 1. If `model_hint` is provided, find a candidate whose `name` (alias)
+///    matches the hint **and** whose protocols include `protocol`.
+/// 2. Else if `model_hint` is provided, find a candidate whose `model`
+///    matches the hint **and** whose protocols include `protocol`.
+/// 3. 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 {
         let normalized_hint = hint.trim().to_ascii_lowercase();
+        // 1. Alias match (route name == model hint).
         if let Some(r) = candidates.iter().find(|r| {
             r.name.trim().to_ascii_lowercase() == normalized_hint
                 && r.protocols.iter().any(|p| p == protocol)
         }) {
             return Some(r);
         }
+        // 2. Model ID match (route model == model hint).
+        if let Some(r) = candidates.iter().find(|r| {
+            r.model.trim().to_ascii_lowercase() == normalized_hint
+                && r.protocols.iter().any(|p| p == protocol)
+        }) {
+            return Some(r);
+        }
     }
+    // 3. First protocol-compatible route.
     candidates
         .iter()
         .find(|r| r.protocols.iter().any(|p| p == protocol))
@@ -273,4 +285,32 @@ mod tests {
         let r = select_route(&routes, "openai_chat_completions", Some("my-gpt")).unwrap();
         assert_eq!(r.name, "My-GPT");
     }
+
+    #[test]
+    fn select_route_model_id_match() {
+        // When the hint doesn't match any alias but does match a route's model,
+        // that route is selected.
+        let routes = vec![
+            make_route("ollama-local", vec!["openai_responses"]),
+            make_route("openai-codex", vec!["openai_responses"]),
+        ];
+        // openai-codex has model "openai-codex-model"; ollama-local has "ollama-local-model".
+        // Hint "openai-codex-model" doesn't match any alias, but matches the model field.
+        let r = select_route(&routes, "openai_responses", Some("openai-codex-model")).unwrap();
+        assert_eq!(r.name, "openai-codex");
+    }
+
+    #[test]
+    fn select_route_alias_beats_model_id() {
+        // Alias match takes priority over model ID match.
+        let mut routes = vec![
+            make_route("ollama-local", vec!["openai_chat_completions"]),
+            make_route("openai-prod", vec!["openai_chat_completions"]),
+        ];
+        // Give ollama-local a model that matches the second route's name.
+        routes[0].model = "openai-prod".to_string();
+        let r = select_route(&routes, "openai_chat_completions", Some("openai-prod")).unwrap();
+        // Alias match wins: route named "openai-prod", not the one with model="openai-prod".
+        assert_eq!(r.name, "openai-prod");
+    }
 }

crates/openshell-sandbox/src/l7/inference.rs

@@ -14,6 +14,10 @@ pub struct InferenceApiPattern {
     pub path_glob: String,
     pub protocol: String,
     pub kind: String,
+    /// When true, the `/v1` version prefix is stripped from the request path
+    /// before forwarding to the backend. This is needed for endpoints whose
+    /// base URL does not include `/v1` (e.g. `chatgpt.com/backend-api`).
+    pub strip_version_prefix: bool,
 }
 
 /// Default patterns for known inference APIs (`OpenAI`, Anthropic).
@@ -24,60 +28,70 @@ pub fn default_patterns() -> Vec<InferenceApiPattern> {
             path_glob: "/v1/chat/completions".to_string(),
             protocol: "openai_chat_completions".to_string(),
             kind: "chat_completion".to_string(),
+            strip_version_prefix: false,
         },
         InferenceApiPattern {
             method: "POST".to_string(),
             path_glob: "/v1/completions".to_string(),
             protocol: "openai_completions".to_string(),
             kind: "completion".to_string(),
+            strip_version_prefix: false,
         },
         InferenceApiPattern {
             method: "POST".to_string(),
             path_glob: "/v1/responses".to_string(),
             protocol: "openai_responses".to_string(),
             kind: "responses".to_string(),
+            strip_version_prefix: false,
         },
         InferenceApiPattern {
             method: "POST".to_string(),
             path_glob: "/v1/codex/*".to_string(),
             protocol: "openai_responses".to_string(),
             kind: "codex_responses".to_string(),
+            strip_version_prefix: true,
         },
         InferenceApiPattern {
             method: "POST".to_string(),
             path_glob: "/v1/messages".to_string(),
             protocol: "anthropic_messages".to_string(),
             kind: "messages".to_string(),
+            strip_version_prefix: false,
         },
         InferenceApiPattern {
             method: "POST".to_string(),
             path_glob: "/api/chat".to_string(),
             protocol: "ollama_chat".to_string(),
             kind: "ollama_chat".to_string(),
+            strip_version_prefix: false,
         },
         InferenceApiPattern {
             method: "GET".to_string(),
             path_glob: "/api/tags".to_string(),
             protocol: "ollama_model_discovery".to_string(),
             kind: "ollama_tags".to_string(),
+            strip_version_prefix: false,
         },
         InferenceApiPattern {
             method: "POST".to_string(),
             path_glob: "/api/show".to_string(),
             protocol: "ollama_model_discovery".to_string(),
             kind: "ollama_show".to_string(),
+            strip_version_prefix: false,
         },
         InferenceApiPattern {
             method: "GET".to_string(),
             path_glob: "/v1/models".to_string(),
             protocol: "model_discovery".to_string(),
             kind: "models_list".to_string(),
+            strip_version_prefix: false,
         },
         InferenceApiPattern {
             method: "GET".to_string(),
             path_glob: "/v1/models/*".to_string(),
             protocol: "model_discovery".to_string(),
             kind: "models_get".to_string(),
+            strip_version_prefix: false,
         },
     ]
 }

crates/openshell-sandbox/src/proxy.rs

@@ -1032,12 +1032,21 @@ async fn route_inference_request(
             .ok()
             .and_then(|v| v.get("model")?.as_str().map(String::from));
 
+        // For patterns like codex that set strip_version_prefix, remove the
+        // /v1 proxy artifact from the path so the backend endpoint base URL
+        // alone controls the path prefix.
+        let routed_path = if pattern.strip_version_prefix && normalized_path.starts_with("/v1/") {
+            &normalized_path[3..]
+        } else {
+            &normalized_path
+        };
+
         match ctx
             .router
             .proxy_with_candidates_streaming(
                 &pattern.protocol,
                 &request.method,
-                &normalized_path,
+                routed_path,
                 filtered_headers,
                 bytes::Bytes::from(request.body.clone()),
                 &routes,