fix(provider): count inherited endpoint formats for model tests

apps/aether-gateway/src/handlers/admin/provider/endpoints_admin/payloads.rs

@@ -1,9 +1,11 @@
 use crate::handlers::admin::shared::AdminTypedObjectPatch;
+use crate::provider_key_auth::provider_key_effective_api_formats;
 use aether_admin::provider::endpoints as admin_provider_endpoints_pure;
 use aether_data_contracts::repository::provider_catalog::{
-    StoredProviderCatalogEndpoint, StoredProviderCatalogKey,
+    StoredProviderCatalogEndpoint, StoredProviderCatalogKey, StoredProviderCatalogProvider,
 };
 use serde::Deserialize;
+use std::collections::{BTreeMap, BTreeSet};
 
 pub(super) fn key_api_formats_without_entry(
     key: &StoredProviderCatalogKey,
@@ -13,12 +15,50 @@ pub(super) fn key_api_formats_without_entry(
 }
 
 pub(super) fn endpoint_key_counts_by_format(
+    provider: &StoredProviderCatalogProvider,
+    endpoints: &[StoredProviderCatalogEndpoint],
     keys: &[StoredProviderCatalogKey],
 ) -> (
     std::collections::BTreeMap<String, usize>,
     std::collections::BTreeMap<String, usize>,
 ) {
-    admin_provider_endpoints_pure::endpoint_key_counts_by_format(keys)
+    let mut active_endpoint_formats = BTreeSet::new();
+    for endpoint in endpoints.iter().filter(|endpoint| endpoint.is_active) {
+        active_endpoint_formats.insert(endpoint.api_format.clone());
+    }
+
+    let mut total_by_format = BTreeMap::<String, BTreeSet<String>>::new();
+    let mut active_by_format = BTreeMap::<String, BTreeSet<String>>::new();
+    for key in keys {
+        for api_format in
+            provider_key_effective_api_formats(key, &provider.provider_type, endpoints)
+        {
+            if !active_endpoint_formats.contains(&api_format) {
+                continue;
+            }
+            total_by_format
+                .entry(api_format.clone())
+                .or_default()
+                .insert(key.id.clone());
+            if key.is_active {
+                active_by_format
+                    .entry(api_format)
+                    .or_default()
+                    .insert(key.id.clone());
+            }
+        }
+    }
+
+    (
+        total_by_format
+            .into_iter()
+            .map(|(api_format, keys)| (api_format, keys.len()))
+            .collect(),
+        active_by_format
+            .into_iter()
+            .map(|(api_format, keys)| (api_format, keys.len()))
+            .collect(),
+    )
 }
 
 pub(super) fn build_admin_provider_endpoint_response(

apps/aether-gateway/src/handlers/admin/provider/endpoints_admin/reads.rs

@@ -38,7 +38,8 @@ pub(crate) async fn build_admin_provider_endpoints_payload(
         .await
         .ok()
         .unwrap_or_default();
-    let (total_keys_by_format, active_keys_by_format) = endpoint_key_counts_by_format(&keys);
+    let (total_keys_by_format, active_keys_by_format) =
+        endpoint_key_counts_by_format(&provider, &endpoints, &keys);
     let now_unix_secs = SystemTime::now()
         .duration_since(UNIX_EPOCH)
         .ok()
@@ -92,7 +93,8 @@ pub(crate) async fn build_admin_endpoint_payload(
         .await
         .ok()
         .unwrap_or_default();
-    let (total_keys_by_format, active_keys_by_format) = endpoint_key_counts_by_format(&keys);
+    let (total_keys_by_format, active_keys_by_format) =
+        endpoint_key_counts_by_format(&provider, std::slice::from_ref(&endpoint), &keys);
     let now_unix_secs = SystemTime::now()
         .duration_since(UNIX_EPOCH)
         .ok()

apps/aether-gateway/src/handlers/admin/provider/endpoints_admin/update.rs

@@ -147,7 +147,8 @@ pub(super) async fn maybe_handle(
         .list_provider_catalog_keys_by_provider_ids(std::slice::from_ref(&provider.id))
         .await
         .unwrap_or_default();
-    let (total_keys_by_format, active_keys_by_format) = endpoint_key_counts_by_format(&keys);
+    let (total_keys_by_format, active_keys_by_format) =
+        endpoint_key_counts_by_format(&provider, std::slice::from_ref(&updated), &keys);
 
     Ok(Some(
         Json(build_admin_provider_endpoint_response(

apps/aether-gateway/src/tests/control/admin/endpoints/routes.rs

@@ -148,6 +148,120 @@ async fn gateway_handles_admin_provider_endpoints_locally_with_trusted_admin_pri
     upstream_handle.abort();
 }
 
+#[tokio::test]
+async fn gateway_counts_fixed_provider_oauth_keys_for_inherited_endpoint_formats() {
+    let mut codex_provider = sample_provider("provider-codex", "codex", 10);
+    codex_provider.provider_type = "codex".to_string();
+    let mut chatgpt_web_provider = sample_provider("provider-chatgpt-web", "chatgpt_web", 20);
+    chatgpt_web_provider.provider_type = "chatgpt_web".to_string();
+
+    let mut codex_key = sample_key(
+        "key-codex-oauth",
+        "provider-codex",
+        "openai:responses:compact",
+        "oauth-token",
+    );
+    codex_key.auth_type = "oauth".to_string();
+    codex_key.api_formats = Some(json!(["legacy:mismatch"]));
+
+    let mut chatgpt_web_key = sample_key(
+        "key-chatgpt-web-oauth",
+        "provider-chatgpt-web",
+        "openai:image",
+        "oauth-token",
+    );
+    chatgpt_web_key.auth_type = "oauth".to_string();
+    chatgpt_web_key.api_formats = Some(json!(["legacy:mismatch"]));
+
+    let provider_catalog_repository = Arc::new(InMemoryProviderCatalogReadRepository::seed(
+        vec![codex_provider, chatgpt_web_provider],
+        vec![
+            sample_endpoint(
+                "endpoint-codex-compact",
+                "provider-codex",
+                "openai:responses:compact",
+                "https://chatgpt.com/backend-api/codex",
+            ),
+            sample_endpoint(
+                "endpoint-codex-image",
+                "provider-codex",
+                "openai:image",
+                "https://chatgpt.com/backend-api/codex",
+            ),
+            sample_endpoint(
+                "endpoint-chatgpt-web-image",
+                "provider-chatgpt-web",
+                "openai:image",
+                "https://chatgpt.com",
+            ),
+        ],
+        vec![codex_key, chatgpt_web_key],
+    ));
+
+    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,
+            )),
+    );
+    let (gateway_url, gateway_handle) = start_server(gateway).await;
+
+    let client = reqwest::Client::new();
+    let codex_response = client
+        .get(format!(
+            "{gateway_url}/api/admin/endpoints/providers/provider-codex/endpoints?skip=0&limit=50"
+        ))
+        .header(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!(codex_response.status(), StatusCode::OK);
+    let codex_payload: serde_json::Value = codex_response.json().await.expect("json should parse");
+    let codex_items = codex_payload
+        .as_array()
+        .expect("payload should be an array");
+    for api_format in ["openai:responses:compact", "openai:image"] {
+        let endpoint = codex_items
+            .iter()
+            .find(|item| item["api_format"] == api_format)
+            .expect("endpoint should exist");
+        assert_eq!(endpoint["total_keys"], 1);
+        assert_eq!(endpoint["active_keys"], 1);
+    }
+
+    let chatgpt_web_response = client
+        .get(format!(
+            "{gateway_url}/api/admin/endpoints/providers/provider-chatgpt-web/endpoints?skip=0&limit=50"
+        ))
+        .header(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!(chatgpt_web_response.status(), StatusCode::OK);
+    let chatgpt_web_payload: serde_json::Value = chatgpt_web_response
+        .json()
+        .await
+        .expect("json should parse");
+    let chatgpt_web_items = chatgpt_web_payload
+        .as_array()
+        .expect("payload should be an array");
+    let chatgpt_web_image = chatgpt_web_items
+        .iter()
+        .find(|item| item["api_format"] == "openai:image")
+        .expect("image endpoint should exist");
+    assert_eq!(chatgpt_web_image["total_keys"], 1);
+    assert_eq!(chatgpt_web_image["active_keys"], 1);
+
+    gateway_handle.abort();
+}
+
 #[tokio::test]
 async fn gateway_returns_service_unavailable_for_admin_provider_endpoint_create_when_catalog_writer_unavailable(
 ) {