fix(provider): 修复 Windsurf Connect 请求与端点计数

apps/aether-gateway/src/execution_runtime/transport.rs

@@ -1470,11 +1470,16 @@ pub(crate) fn decode_response_body_bytes(
 }
 
 pub(crate) fn response_body_is_json(headers: &BTreeMap<String, String>, body_bytes: &[u8]) -> bool {
-    if headers
+    let content_type = headers
         .get("content-type")
         .map(|value| value.to_ascii_lowercase())
-        .is_some_and(|value| value.contains("json"))
+        .unwrap_or_default();
+    if content_type.contains("application/connect+json")
+        || content_type.contains("application/connect+proto")
     {
+        return false;
+    }
+    if content_type.contains("json") {
         return true;
     }
 
@@ -1508,7 +1513,7 @@ mod tests {
         build_browser_wreq_client, build_client, build_request_headers, execute_sync_plan,
         record_manual_proxy_request_failure, record_manual_proxy_request_outcome,
         record_manual_proxy_request_success, record_manual_proxy_stream_error,
-        resolve_execution_transport_controls, DirectSyncExecutionRuntime,
+        resolve_execution_transport_controls, response_body_is_json, DirectSyncExecutionRuntime,
         ExecutionRuntimeTransportError, ExecutionTransportControls,
     };
     use crate::constants::{
@@ -2764,6 +2769,17 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn connect_json_response_is_not_treated_as_plain_json() {
+        let headers = BTreeMap::from([(
+            "content-type".to_string(),
+            "application/connect+json".to_string(),
+        )]);
+        let body = [2, 0, 0, 0, 2, b'{', b'}'];
+
+        assert!(!response_body_is_json(&headers, &body));
+    }
+
     #[tokio::test]
     async fn direct_sync_execution_runtime_compresses_json_body_when_requested() {
         let listener = crate::test_support::bind_loopback_listener()

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

@@ -1,6 +1,6 @@
 use crate::handlers::admin::request::AdminAppState;
 use aether_data_contracts::repository::provider_catalog::{
-    StoredProviderCatalogEndpoint, StoredProviderCatalogProvider,
+    StoredProviderCatalogEndpoint, StoredProviderCatalogKey, StoredProviderCatalogProvider,
 };
 use std::time::{SystemTime, UNIX_EPOCH};
 

apps/aether-gateway/src/handlers/admin/provider/query/models/model_test.rs

@@ -14,7 +14,7 @@ use super::{provider_query_key_display_name, provider_query_provider_payload};
 use crate::ai_serving::{
     maybe_build_sync_finalize_outcome, GatewayControlDecision,
     ANTIGRAVITY_V1INTERNAL_ENVELOPE_NAME, GEMINI_CHAT_SYNC_FINALIZE_REPORT_KIND,
-    OPENAI_IMAGE_SYNC_FINALIZE_REPORT_KIND,
+    OPENAI_CHAT_SYNC_FINALIZE_REPORT_KIND, OPENAI_IMAGE_SYNC_FINALIZE_REPORT_KIND,
 };
 use crate::clock::current_unix_ms;
 use crate::execution_runtime;
@@ -1786,6 +1786,56 @@ async fn provider_query_execute_kiro_test_candidate(
     })
 }
 
+async fn provider_query_finalize_windsurf_result(
+    route_path: &str,
+    trace_id: &str,
+    requested_model: &str,
+    mapped_model: &str,
+    original_request_body: &Value,
+    result: &aether_contracts::ExecutionResult,
+) -> Result<Option<Value>, GatewayError> {
+    let decision = GatewayControlDecision::synthetic(
+        route_path,
+        Some("admin_proxy".to_string()),
+        Some("provider_query_manage".to_string()),
+        Some("test_model_failover".to_string()),
+        Some("openai:chat".to_string()),
+    );
+    let payload = GatewaySyncReportRequest {
+        trace_id: trace_id.to_string(),
+        report_kind: OPENAI_CHAT_SYNC_FINALIZE_REPORT_KIND.to_string(),
+        report_context: Some(json!({
+            "client_api_format": "openai:chat",
+            "provider_api_format": "openai:chat",
+            "model": requested_model,
+            "mapped_model": mapped_model,
+            "needs_conversion": false,
+            "has_envelope": true,
+            "envelope_name": crate::provider_transport::windsurf::WINDSURF_ENVELOPE_NAME,
+            "original_request_body": original_request_body,
+        })),
+        status_code: result.status_code,
+        headers: result.headers.clone(),
+        body_json: result.body.as_ref().and_then(|body| body.json_body.clone()),
+        client_body_json: None,
+        body_base64: result
+            .body
+            .as_ref()
+            .and_then(|body| body.body_bytes_b64.clone()),
+        telemetry: result.telemetry.clone(),
+    };
+
+    let Some(outcome) = maybe_build_sync_finalize_outcome(trace_id, &decision, &payload)? else {
+        return Ok(None);
+    };
+    let bytes = to_bytes(outcome.response.into_body(), usize::MAX)
+        .await
+        .map_err(|err| GatewayError::Internal(err.to_string()))?;
+    serde_json::from_slice::<Value>(&bytes)
+        .map(Some)
+        .map_err(|err| GatewayError::Internal(err.to_string()))
+}
+
 fn provider_query_build_openai_image_test_request_body_for_route(
     payload: &Value,
     model: &str,
@@ -3194,7 +3244,7 @@ async fn provider_query_execute_windsurf_test_candidate(
         method: "POST".to_string(),
         url: request_url.clone(),
         headers: request_headers.clone(),
-        content_type: Some("application/json".to_string()),
+        content_type: Some("application/connect+json".to_string()),
         content_encoding: None,
         body: RequestBody::from_json(provider_request_body.clone()),
         stream: upstream_is_stream,
@@ -3211,7 +3261,19 @@ async fn provider_query_execute_windsurf_test_candidate(
     let result = state
         .execute_execution_runtime_sync_plan(Some(trace_id), &plan)
         .await?;
-    let response_body = result.body.as_ref().and_then(|body| body.json_body.clone());
+    let response_body = if result.status_code < 400 {
+        provider_query_finalize_windsurf_result(
+            route_path,
+            trace_id,
+            request_model,
+            request_model,
+            &request_body,
+            &result,
+        )
+        .await?
+    } else {
+        result.body.as_ref().and_then(|body| body.json_body.clone())
+    };
     let missing_success_body = result.status_code < 400 && response_body.is_none();
     let did_fail = result.status_code >= 400 || missing_success_body;
     let error_message = if did_fail {

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

@@ -347,6 +347,78 @@ async fn gateway_counts_keys_with_null_api_formats_for_each_fixed_provider_endpo
     upstream_handle.abort();
 }
 
+#[tokio::test]
+async fn gateway_counts_inherited_windsurf_key_formats_for_admin_provider_endpoints() {
+    let upstream_hits = Arc::new(Mutex::new(0usize));
+    let upstream_hits_clone = Arc::clone(&upstream_hits);
+    let upstream = Router::new().route(
+        "/api/admin/endpoints/providers/provider-windsurf/endpoints",
+        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 key = sample_key(
+        "key-windsurf-a",
+        "provider-windsurf",
+        "openai:chat",
+        "oauth-secret",
+    );
+    key.auth_type = "oauth".to_string();
+    key.api_formats = None;
+
+    let mut provider = sample_provider("provider-windsurf", "windsurf", 10);
+    provider.provider_type = "windsurf".to_string();
+    let provider_catalog_repository = Arc::new(InMemoryProviderCatalogReadRepository::seed(
+        vec![provider],
+        vec![sample_endpoint(
+            "endpoint-windsurf-chat",
+            "provider-windsurf",
+            "openai:chat",
+            "https://server.codeium.com",
+        )],
+        vec![key],
+    ));
+
+    let (_, 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,
+            )),
+    );
+    let (gateway_url, gateway_handle) = start_server(gateway).await;
+
+    let response = reqwest::Client::new()
+        .get(format!(
+            "{gateway_url}/api/admin/endpoints/providers/provider-windsurf/endpoints?skip=0&limit=50"
+        ))
+        .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");
+    let items = payload.as_array().expect("payload should be an array");
+    assert_eq!(items.len(), 1);
+    assert_eq!(items[0]["id"], "endpoint-windsurf-chat");
+    assert_eq!(items[0]["total_keys"], 1);
+    assert_eq!(items[0]["active_keys"], 1);
+    assert_eq!(*upstream_hits.lock().expect("mutex should lock"), 0);
+
+    gateway_handle.abort();
+    upstream_handle.abort();
+}
+
 #[tokio::test]
 async fn gateway_returns_service_unavailable_for_admin_provider_endpoint_create_when_catalog_writer_unavailable(
 ) {