fix(routing): match provider model names in admin routing counts

apps/aether-gateway/src/handlers/admin/model/routing.rs

@@ -107,6 +107,13 @@ pub(crate) async fn build_admin_global_model_routing_payload(
         let Some(provider) = providers.get(&model.provider_id) else {
             continue;
         };
+        let provider_model_mapping_names =
+            provider_model_mapping_names_for_routing(model.provider_model_mappings.as_ref());
+        let key_match_model_names = key_match_model_names_for_routing(
+            &global_model.name,
+            &model.provider_model_name,
+            &provider_model_mapping_names,
+        );
         let mut endpoint_payloads = Vec::new();
         let mut active_endpoints = 0usize;
         for endpoint in endpoints_by_provider
@@ -132,7 +139,7 @@ pub(crate) async fn build_admin_global_model_routing_payload(
                 .filter(|key| {
                     key_allowed_models_match_global_model_for_routing(
                         key.allowed_models.as_ref(),
-                        &global_model.name,
+                        &key_match_model_names,
                         &global_model_mappings,
                     )
                 })
@@ -313,7 +320,7 @@ pub(crate) async fn build_admin_global_model_routing_payload(
 
 fn key_allowed_models_match_global_model_for_routing(
     raw_allowed_models: Option<&serde_json::Value>,
-    global_model_name: &str,
+    model_names: &[String],
     global_model_mappings: &[String],
 ) -> bool {
     // 兼容 Python 预览逻辑：None/[] 视为“不限制”，在链路预览中保留该 Key。
@@ -322,14 +329,16 @@ fn key_allowed_models_match_global_model_for_routing(
         return true;
     }
 
-    if allowed_models
+    for allowed_model in allowed_models.iter().map(String::as_str).map(str::trim) {
-        .iter()
+        if allowed_model.is_empty() {
-        .any(|value| value == global_model_name)
+            continue;
-    {
+        }
-        return true;
+        if model_names
-    }
+            .iter()
-
+            .any(|model_name| model_name.eq_ignore_ascii_case(allowed_model))
-    for allowed_model in &allowed_models {
+        {
+            return true;
+        }
         for pattern in global_model_mappings {
             if matches_model_mapping(pattern, allowed_model) {
                 return true;
@@ -340,6 +349,54 @@ fn key_allowed_models_match_global_model_for_routing(
     false
 }
 
+fn provider_model_mapping_names_for_routing(
+    raw_mappings: Option<&serde_json::Value>,
+) -> Vec<String> {
+    raw_mappings
+        .and_then(serde_json::Value::as_array)
+        .map(|items| {
+            items
+                .iter()
+                .filter_map(|item| {
+                    item.as_str()
+                        .or_else(|| item.get("name").and_then(serde_json::Value::as_str))
+                })
+                .map(str::trim)
+                .filter(|value| !value.is_empty())
+                .map(ToOwned::to_owned)
+                .collect::<Vec<_>>()
+        })
+        .unwrap_or_default()
+}
+
+fn key_match_model_names_for_routing(
+    global_model_name: &str,
+    provider_model_name: &str,
+    provider_model_mapping_names: &[String],
+) -> Vec<String> {
+    let mut names = Vec::new();
+    push_unique_model_name(&mut names, global_model_name);
+    push_unique_model_name(&mut names, provider_model_name);
+    for mapping_name in provider_model_mapping_names {
+        push_unique_model_name(&mut names, mapping_name);
+    }
+    names
+}
+
+fn push_unique_model_name(names: &mut Vec<String>, value: &str) {
+    let value = value.trim();
+    if value.is_empty() {
+        return;
+    }
+    if names
+        .iter()
+        .any(|existing| existing.eq_ignore_ascii_case(value))
+    {
+        return;
+    }
+    names.push(value.to_string());
+}
+
 pub(crate) async fn build_admin_assign_global_model_to_providers_payload(
     state: &AdminAppState<'_>,
     global_model_id: &str,

apps/aether-gateway/src/tests/control/admin/models/global.rs

@@ -936,6 +936,142 @@ async fn gateway_handles_admin_global_model_routing_locally_with_trusted_admin_p
     upstream_handle.abort();
 }
 
+#[tokio::test]
+async fn gateway_global_model_routing_counts_image_provider_keys_by_provider_model_name() {
+    let upstream_hits = Arc::new(Mutex::new(0usize));
+    let upstream_hits_clone = Arc::clone(&upstream_hits);
+    let upstream = Router::new().route(
+        "/api/admin/models/global/global-gpt-image/routing",
+        any(move |_request: Request| {
+            let upstream_hits_inner = Arc::clone(&upstream_hits_clone);
+            async move {
+                *upstream_hits_inner.lock().expect("mutex should lock") += 1;
+                (StatusCode::OK, Body::from("unexpected upstream hit"))
+            }
+        }),
+    );
+
+    let mut image_provider = sample_provider("provider-image", "image", 10);
+    image_provider.provider_type = "chatgpt_web".to_string();
+    let grok_provider = sample_provider("provider-grok", "grok2api", 20);
+
+    let mut image_key = sample_key(
+        "key-image-routing",
+        "provider-image",
+        "legacy:mismatch",
+        "sk-image-routing-1234",
+    );
+    image_key.name = "image-account".to_string();
+    image_key.auth_type = "oauth".to_string();
+    image_key.allowed_models = Some(json!(["gpt-image-2"]));
+
+    let mut grok_key = sample_key(
+        "key-grok-routing",
+        "provider-grok",
+        "openai:chat",
+        "sk-grok-routing-5678",
+    );
+    grok_key.name = "all".to_string();
+    grok_key.allowed_models = Some(json!(["gpt-image-2"]));
+
+    let provider_catalog_repository = Arc::new(InMemoryProviderCatalogReadRepository::seed(
+        vec![image_provider, grok_provider],
+        vec![
+            sample_endpoint(
+                "endpoint-image",
+                "provider-image",
+                "openai:image",
+                "https://chatgpt.example",
+            ),
+            sample_endpoint(
+                "endpoint-grok-chat",
+                "provider-grok",
+                "openai:chat",
+                "https://grok.example",
+            ),
+        ],
+        vec![image_key, grok_key],
+    ));
+    let global_model_repository = Arc::new(
+        InMemoryGlobalModelReadRepository::seed(Vec::new())
+            .with_admin_global_models(vec![sample_admin_global_model(
+                "global-gpt-image",
+                "GPT-Image-2",
+                "GPT-Image-2",
+            )])
+            .with_admin_provider_models(vec![
+                sample_admin_provider_model(
+                    "model-image-gpt-image",
+                    "provider-image",
+                    "global-gpt-image",
+                    "gpt-image-2",
+                ),
+                sample_admin_provider_model(
+                    "model-grok-gpt-image",
+                    "provider-grok",
+                    "global-gpt-image",
+                    "gpt-image-2",
+                ),
+            ]),
+    );
+
+    let (upstream_url, upstream_handle) = start_server(upstream).await;
+    let gateway = build_router_with_state(
+        AppState::new()
+            .expect("gateway should build")
+            .with_data_state_for_tests(
+                GatewayDataState::with_provider_catalog_reader_for_tests(
+                    provider_catalog_repository,
+                )
+                .with_global_model_repository_for_tests(global_model_repository),
+            ),
+    );
+    let (gateway_url, gateway_handle) = start_server(gateway).await;
+
+    let response = reqwest::Client::new()
+        .get(format!(
+            "{gateway_url}/api/admin/models/global/global-gpt-image/routing"
+        ))
+        .header(crate::constants::GATEWAY_HEADER, "rust-phase3b")
+        .header(TRUSTED_ADMIN_USER_ID_HEADER, "admin-user-123")
+        .header(TRUSTED_ADMIN_USER_ROLE_HEADER, "admin")
+        .header(TRUSTED_ADMIN_SESSION_ID_HEADER, "session-123")
+        .send()
+        .await
+        .expect("request should succeed");
+
+    assert_eq!(response.status(), StatusCode::OK);
+    let payload: serde_json::Value = response.json().await.expect("json body should parse");
+    assert_eq!(payload["global_model_name"], "GPT-Image-2");
+    assert_eq!(payload["total_providers"], 2);
+    assert_eq!(payload["active_providers"], 2);
+
+    let providers = payload["providers"].as_array().expect("providers array");
+    assert_eq!(providers.len(), 2);
+
+    let image_endpoints = providers[0]["endpoints"]
+        .as_array()
+        .expect("image endpoints array");
+    assert_eq!(providers[0]["id"], "provider-image");
+    assert_eq!(image_endpoints[0]["api_format"], "openai:image");
+    assert_eq!(image_endpoints[0]["total_keys"], 1);
+    assert_eq!(image_endpoints[0]["active_keys"], 1);
+    assert_eq!(image_endpoints[0]["keys"][0]["name"], "image-account");
+
+    let grok_endpoints = providers[1]["endpoints"]
+        .as_array()
+        .expect("grok endpoints array");
+    assert_eq!(providers[1]["id"], "provider-grok");
+    assert_eq!(grok_endpoints[0]["api_format"], "openai:chat");
+    assert_eq!(grok_endpoints[0]["total_keys"], 1);
+    assert_eq!(grok_endpoints[0]["active_keys"], 1);
+    assert_eq!(grok_endpoints[0]["keys"][0]["name"], "all");
+    assert_eq!(*upstream_hits.lock().expect("mutex should lock"), 0);
+
+    gateway_handle.abort();
+    upstream_handle.abort();
+}
+
 #[tokio::test]
 async fn gateway_creates_admin_global_model_locally_with_trusted_admin_principal() {
     let upstream_hits = Arc::new(Mutex::new(0usize));

frontend/src/features/models/components/RoutingTab.vue

@@ -784,7 +784,9 @@ function targetFormatsForEndpoint(
   provider: RoutingProviderInfo,
   endpoint: RoutingEndpointInfo
 ): string[] {
-  return STANDARD_ROUTING_API_FORMATS.filter(format =>
+  const endpointFormat = normalizeLegacyOpenAIFormatAlias(endpoint.api_format)
+  const candidateFormats = Array.from(new Set([...STANDARD_ROUTING_API_FORMATS, endpointFormat]))
+  return candidateFormats.filter(format =>
     endpointSupportsClientFormat(provider, endpoint, format, endpoint.api_format)
   )
 }