Merge remote-tracking branch 'origin/pr-483' into merge-pr-483

# Conflicts: # apps/aether-gateway/src/ai_serving/planner/standard/openai/chat/decision/payload.rs # apps/aether-gateway/src/ai_serving/planner/standard/openai/chat/decision/request.rs # apps/aether-gateway/src/ai_serving/planner/standard/openai/responses/decision/payload.rs # apps/aether-gateway/src/ai_serving/planner/standard/openai/responses/decision/request.rs # apps/aether-gateway/src/execution_runtime/chatgpt_web_image.rs
2026-10-04 08:27:46 +08:00 · 2026-05-19 02:23:14 +08:00
parent afedd90c80 c58ce63fc3
commit c563c192b7
53 changed files with 8081 additions and 305 deletions
@@ -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_counts_keys_with_null_api_formats_for_each_fixed_provider_endpoint() {
    let upstream_hits = Arc::new(Mutex::new(0usize));
@@ -195,7 +309,7 @@ async fn gateway_counts_keys_with_null_api_formats_for_each_fixed_provider_endpo
        vec![inherited_key],
    ));

-    let (upstream_url, upstream_handle) = start_server(upstream).await;
+    let (_, upstream_handle) = start_server(upstream).await;
    let gateway = build_router_with_state(
        AppState::new()
            .expect("gateway should build")
@@ -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));