修复 Antigravity OAuth 配额复检缺 project

apps/aether-gateway/src/ai_serving/planner/passthrough/provider/family/request.rs

@@ -14,6 +14,7 @@ use crate::ai_serving::transport::antigravity::{
     build_antigravity_safe_v1internal_request, build_antigravity_static_identity_headers,
     classify_local_antigravity_request_support, AntigravityEnvelopeRequestType,
     AntigravityRequestEnvelopeSupport, AntigravityRequestSideSupport,
+    AntigravityRequestSideUnsupportedReason,
 };
 use crate::ai_serving::transport::{
     build_gemini_cli_v1internal_request, build_grok_browser_headers, build_grok_upstream_url,
@@ -230,11 +231,32 @@ pub(crate) async fn resolve_local_same_format_provider_candidate_payload_parts(
     }
 
     let antigravity_auth = if prepared.is_antigravity {
-        match classify_local_antigravity_request_support(
+        let mut antigravity_support = classify_local_antigravity_request_support(
             &transport,
             &base_provider_request_body,
             AntigravityEnvelopeRequestType::Agent,
+        );
+        if matches!(
+            antigravity_support,
+            AntigravityRequestSideSupport::Unsupported(
+                AntigravityRequestSideUnsupportedReason::UnsupportedAuth(
+                    crate::provider_transport::antigravity::AntigravityRequestAuthUnsupportedReason::MissingProjectId
+                )
+            )
         ) {
+            if let Some(hydrated) = state
+                .hydrate_antigravity_project_metadata_for_transport(&transport)
+                .await
+            {
+                transport = Arc::new(hydrated);
+                antigravity_support = classify_local_antigravity_request_support(
+                    &transport,
+                    &base_provider_request_body,
+                    AntigravityEnvelopeRequestType::Agent,
+                );
+            }
+        }
+        match antigravity_support {
             AntigravityRequestSideSupport::Supported(spec) => Some(spec.auth),
             AntigravityRequestSideSupport::Unsupported(_) => {
                 mark_skipped_local_same_format_provider_candidate(

apps/aether-gateway/src/ai_serving/planner/standard/openai/responses/decision/request.rs

@@ -33,7 +33,7 @@ use crate::ai_serving::transport::antigravity::{
     build_antigravity_safe_v1internal_request, build_antigravity_static_identity_headers,
     classify_local_antigravity_request_support, is_antigravity_provider_transport,
     AntigravityEnvelopeRequestType, AntigravityRequestEnvelopeSupport,
-    AntigravityRequestSideSupport,
+    AntigravityRequestSideSupport, AntigravityRequestSideUnsupportedReason,
 };
 use crate::ai_serving::transport::auth::{
     resolve_local_gemini_auth, resolve_local_openai_bearer_auth, resolve_local_standard_auth,
@@ -119,11 +119,11 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
     let provider_api_format = eligible.provider_api_format.as_str();
     let normalized_provider_api_format =
         crate::ai_serving::normalize_api_format_alias(provider_api_format);
-    let transport = &eligible.transport;
-    let transport_profile = crate::ai_serving::transport::resolve_transport_profile(transport);
-    let is_antigravity = is_antigravity_provider_transport(transport);
-    let is_gemini_cli = is_gemini_cli_provider_transport(transport);
-    let is_kiro_claude_cli = is_kiro_claude_messages_transport(transport, provider_api_format);
+    let mut transport = Arc::clone(&eligible.transport);
+    let transport_profile = crate::ai_serving::transport::resolve_transport_profile(&transport);
+    let is_antigravity = is_antigravity_provider_transport(&transport);
+    let is_gemini_cli = is_gemini_cli_provider_transport(&transport);
+    let is_kiro_claude_cli = is_kiro_claude_messages_transport(&transport, provider_api_format);
     let is_grok = transport
         .provider
         .provider_type
@@ -145,33 +145,34 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
         .await);
     }
     let is_windsurf_cascade =
-        provider_api_format == "openai:chat" && is_windsurf_provider_transport(transport);
+        provider_api_format == "openai:chat" && is_windsurf_provider_transport(&transport);
 
     let same_format = api_format_alias_matches(provider_api_format, &client_api_format);
     let conversion_kind = request_conversion_kind(spec_metadata.api_format, provider_api_format);
-    let transport_unsupported_reason =
-        if is_grok && is_grok_text_provider_api_format(provider_api_format) {
-            None
-        } else if same_format && is_kiro_claude_cli {
-            local_kiro_request_transport_unsupported_reason_with_network(transport)
-        } else if same_format {
-            local_standard_transport_unsupported_reason_with_network(transport, provider_api_format)
-        } else if is_windsurf_cascade {
-            local_windsurf_request_transport_unsupported_reason_with_network(transport)
-        } else {
-            match conversion_kind {
-                Some(_)
-                    if (is_antigravity || is_gemini_cli)
-                        && normalized_provider_api_format == "gemini:generate_content" =>
-                {
-                    None
-                }
-                Some(kind) => crate::ai_serving::request_conversion_transport_unsupported_reason(
-                    transport, kind,
-                ),
-                None => Some("transport_api_format_unsupported"),
+    let transport_unsupported_reason = if is_grok
+        && is_grok_text_provider_api_format(provider_api_format)
+    {
+        None
+    } else if same_format && is_kiro_claude_cli {
+        local_kiro_request_transport_unsupported_reason_with_network(&transport)
+    } else if same_format {
+        local_standard_transport_unsupported_reason_with_network(&transport, provider_api_format)
+    } else if is_windsurf_cascade {
+        local_windsurf_request_transport_unsupported_reason_with_network(&transport)
+    } else {
+        match conversion_kind {
+            Some(_)
+                if (is_antigravity || is_gemini_cli)
+                    && normalized_provider_api_format == "gemini:generate_content" =>
+            {
+                None
             }
-        };
+            Some(kind) => {
+                crate::ai_serving::request_conversion_transport_unsupported_reason(&transport, kind)
+            }
+            None => Some("transport_api_format_unsupported"),
+        }
+    };
     if let Some(skip_reason) = transport_unsupported_reason {
         mark_skipped_local_openai_responses_candidate(
             state,
@@ -194,7 +195,7 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
     let kiro_auth = if is_kiro_claude_cli {
         match crate::ai_serving::planner::candidate_preparation::resolve_candidate_oauth_auth(
             planner_state,
-            transport,
+            &transport,
             oauth_context,
         )
         .await
@@ -219,20 +220,20 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
     };
 
     let direct_auth = if is_grok && is_grok_text_provider_api_format(provider_api_format) {
-        crate::ai_serving::transport::resolve_grok_session_auth(transport)
+        crate::ai_serving::transport::resolve_grok_session_auth(&transport)
     } else if kiro_auth.is_some() {
         None
     } else if same_format {
         match crate::ai_serving::normalize_api_format_alias(provider_api_format).as_str() {
-            "gemini:generate_content" => resolve_local_gemini_auth(transport),
-            "claude:messages" => resolve_local_standard_auth(transport),
+            "gemini:generate_content" => resolve_local_gemini_auth(&transport),
+            "claude:messages" => resolve_local_standard_auth(&transport),
             "openai:responses" | "openai:responses:compact" => {
-                resolve_local_openai_bearer_auth(transport)
+                resolve_local_openai_bearer_auth(&transport)
             }
             _ => None,
         }
     } else {
-        conversion_kind.and_then(|kind| request_conversion_direct_auth(transport, kind))
+        conversion_kind.and_then(|kind| request_conversion_direct_auth(&transport, kind))
     };
     let prepared_candidate = if let Some(kiro_auth) = kiro_auth.as_ref() {
         match prepare_header_authenticated_candidate_from_auth(
@@ -258,7 +259,7 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
     } else {
         match prepare_header_authenticated_candidate(
             planner_state,
-            transport,
+            &transport,
             candidate,
             direct_auth,
             oauth_context,
@@ -414,11 +415,32 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
         Some(body_json),
     );
     let antigravity_auth = if is_antigravity {
-        match classify_local_antigravity_request_support(
-            transport,
+        let mut antigravity_support = classify_local_antigravity_request_support(
+            &transport,
             &base_provider_request_body,
             AntigravityEnvelopeRequestType::Agent,
+        );
+        if matches!(
+            antigravity_support,
+            AntigravityRequestSideSupport::Unsupported(
+                AntigravityRequestSideUnsupportedReason::UnsupportedAuth(
+                    crate::provider_transport::antigravity::AntigravityRequestAuthUnsupportedReason::MissingProjectId
+                )
+            )
         ) {
+            if let Some(hydrated) = state
+                .hydrate_antigravity_project_metadata_for_transport(&transport)
+                .await
+            {
+                transport = Arc::new(hydrated);
+                antigravity_support = classify_local_antigravity_request_support(
+                    &transport,
+                    &base_provider_request_body,
+                    AntigravityEnvelopeRequestType::Agent,
+                );
+            }
+        }
+        match antigravity_support {
             AntigravityRequestSideSupport::Supported(spec) => Some(spec.auth),
             AntigravityRequestSideSupport::Unsupported(_) => {
                 mark_skipped_local_openai_responses_candidate(
@@ -480,7 +502,7 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
             candidate_index,
             candidate_id,
             spec_metadata.api_format,
-            transport,
+            &transport,
             provider_api_format,
             mapped_model,
             auth_header,
@@ -504,7 +526,7 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
             candidate_index,
             candidate_id,
             spec_metadata.api_format,
-            transport,
+            &transport,
             provider_api_format,
             mapped_model,
             auth_header,
@@ -516,7 +538,7 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
         .await);
     }
     if provider_api_format == "gemini:generate_content"
-        && is_gemini_cli_provider_transport(transport)
+        && is_gemini_cli_provider_transport(&transport)
     {
         return Ok(build_gemini_cli_openai_responses_payload_parts(
             state,
@@ -528,7 +550,7 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
             candidate_index,
             candidate_id,
             spec_metadata.api_format,
-            transport,
+            &transport,
             provider_api_format,
             mapped_model,
             auth_header,
@@ -541,11 +563,11 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
     }
 
     let Some(upstream_url) = (if is_grok && is_grok_text_provider_api_format(provider_api_format) {
-        Some(build_grok_upstream_url(transport, GROK_CHAT_PATH))
+        Some(build_grok_upstream_url(&transport, GROK_CHAT_PATH))
     } else if needs_bidirectional_conversion {
         build_cross_format_openai_responses_upstream_url(
             parts,
-            transport,
+            &transport,
             &mapped_model,
             spec_metadata.api_format,
             provider_api_format,
@@ -554,7 +576,7 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
     } else {
         build_local_openai_responses_upstream_url(
             parts,
-            transport,
+            &transport,
             api_format_alias_matches(provider_api_format, "openai:responses:compact"),
         )
     }) else {
@@ -581,7 +603,7 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
         .unwrap_or_default();
     let resolved_headers = if is_grok && is_grok_text_provider_api_format(provider_api_format) {
         let Some(headers) = build_grok_browser_headers(GrokHeaderInput {
-            transport,
+            transport: &transport,
             transport_profile: transport_profile.as_ref(),
             request_headers: Some(effective_headers),
             content_type: "application/json",
@@ -615,7 +637,7 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
     } else {
         let Some(resolved_headers) =
             build_standard_provider_request_headers(StandardProviderRequestHeadersInput {
-                transport,
+                transport: &transport,
                 provider_api_format,
                 same_format,
                 headers: effective_headers,
@@ -709,7 +731,7 @@ pub(crate) async fn resolve_local_openai_responses_candidate_payload_parts(
             None
         },
         upstream_is_stream,
-        transport: Arc::clone(transport),
+        transport: Arc::clone(&transport),
         transport_profile,
         image_request_summary: None,
         request_redacted: redaction.redacted,