Add Antigravity v1internal gateway adapter

apps/aether-gateway/src/tests/ai_execute/stream_provider_gemini/local_cli.rs

@@ -1950,6 +1950,127 @@ async fn gateway_executes_antigravity_gemini_cli_stream_via_local_decision_gate_
     assert_eq!(stored_candidates.len(), 1);
     assert_eq!(stored_candidates[0].status, RequestCandidateStatus::Success);
 
+    *seen_execution_runtime.lock().expect("mutex should lock") = None;
+    let inbound_response = reqwest::Client::new()
+        .post(format!(
+            "{gateway_url}/v1internal:streamGenerateContent?alt=sse"
+        ))
+        .header(http::header::CONTENT_TYPE, "application/json")
+        .header("authorization", "Bearer google-antigravity-access-token")
+        .header("x-api-key", client_api_key)
+        .header("user-agent", "antigravity/cli/1.0.2 linux/arm64")
+        .header(
+            TRACE_ID_HEADER,
+            "trace-antigravity-v1internal-inbound-stream-456",
+        )
+        .json(&json!({
+            "project": "client-side-project-should-not-leak",
+            "requestId": "client-v1internal-request-456",
+            "model": "gemini-cli",
+            "userAgent": "antigravity",
+            "requestType": "checkpoint",
+            "request": {
+                "contents": [{
+                    "role": "user",
+                    "parts": [{"text": "checkpoint context"}]
+                }],
+                "generationConfig": {
+                    "temperature": 0.4,
+                    "thinkingConfig": {
+                        "includeThoughts": true
+                    }
+                },
+                "toolConfig": {
+                    "functionCallingConfig": {
+                        "mode": "NONE"
+                    }
+                }
+            }
+        }))
+        .send()
+        .await
+        .expect("inbound antigravity request should succeed");
+
+    let inbound_status = inbound_response.status();
+    let inbound_miss_reason = inbound_response
+        .headers()
+        .get(crate::constants::LOCAL_EXECUTION_RUNTIME_MISS_REASON_HEADER)
+        .and_then(|value| value.to_str().ok())
+        .unwrap_or("-")
+        .to_string();
+    let inbound_response_body = inbound_response.text().await.expect("body should read");
+    assert_eq!(
+        inbound_status,
+        StatusCode::OK,
+        "unexpected inbound antigravity response body: {inbound_response_body}; miss_reason={inbound_miss_reason}"
+    );
+    let inbound_response_text = strip_sse_keepalive_comments(&inbound_response_body);
+    let inbound_payload = inbound_response_text
+        .trim()
+        .strip_prefix("data: ")
+        .expect("response should start with sse data prefix");
+    let inbound_response_json: serde_json::Value =
+        serde_json::from_str(inbound_payload).expect("stream payload should parse");
+    assert_eq!(
+        inbound_response_json["_v1internal_response_id"],
+        "resp_antigravity_cli_local_stream_123"
+    );
+    assert_eq!(
+        inbound_response_json["candidates"][0]["content"]["parts"][0]["text"],
+        "Hello Antigravity Stream"
+    );
+
+    let seen_inbound_execution_runtime_request = seen_execution_runtime
+        .lock()
+        .expect("mutex should lock")
+        .clone()
+        .expect("inbound execution runtime stream should be captured");
+    assert_eq!(
+        seen_inbound_execution_runtime_request.trace_id,
+        "trace-antigravity-v1internal-inbound-stream-456"
+    );
+    assert_eq!(
+        seen_inbound_execution_runtime_request.url,
+        "https://antigravity.googleapis.com/v1internal:streamGenerateContent?alt=sse"
+    );
+    assert_eq!(
+        seen_inbound_execution_runtime_request.authorization,
+        "Bearer refreshed-antigravity-cli-stream-access-token"
+    );
+    assert_eq!(
+        seen_inbound_execution_runtime_request.project,
+        "project-antigravity-stream-local-1"
+    );
+    assert_eq!(
+        seen_inbound_execution_runtime_request.request_id,
+        "client-v1internal-request-456"
+    );
+    assert_eq!(
+        seen_inbound_execution_runtime_request.model,
+        "claude-sonnet-4-5"
+    );
+    assert_eq!(
+        seen_inbound_execution_runtime_request.user_agent,
+        "antigravity"
+    );
+    assert_eq!(
+        seen_inbound_execution_runtime_request.request_type,
+        "checkpoint"
+    );
+    assert_eq!(seen_inbound_execution_runtime_request.contents_len, 1);
+    assert!((seen_inbound_execution_runtime_request.exact_temperature - 0.4).abs() < f64::EPSILON);
+    assert!(!seen_inbound_execution_runtime_request.request_has_model);
+
+    let inbound_stored_candidates = request_candidate_repository
+        .list_by_request_id("trace-antigravity-v1internal-inbound-stream-456")
+        .await
+        .expect("inbound request candidate trace should read");
+    assert_eq!(inbound_stored_candidates.len(), 1);
+    assert_eq!(
+        inbound_stored_candidates[0].status,
+        RequestCandidateStatus::Success
+    );
+
     tokio::time::sleep(std::time::Duration::from_millis(100)).await;
     assert!(
         !*seen_report.lock().expect("mutex should lock"),

apps/aether-gateway/src/tests/frontdoor/ai.rs

@@ -700,6 +700,138 @@ async fn gateway_rejects_invalid_claude_count_tokens_payload_without_hitting_fal
     fallback_probe_handle.abort();
 }
 
+#[tokio::test]
+async fn gateway_handles_antigravity_v1internal_control_plane_without_proxying() {
+    let fallback_probe_hits = Arc::new(Mutex::new(0usize));
+    let fallback_probe_hits_clone = Arc::clone(&fallback_probe_hits);
+    let fallback_probe = Router::new().route(
+        "/{*path}",
+        any(move |_request: Request| {
+            let fallback_probe_hits_inner = Arc::clone(&fallback_probe_hits_clone);
+            async move {
+                *fallback_probe_hits_inner.lock().expect("mutex should lock") += 1;
+                (StatusCode::OK, Json(json!({"proxied": true}))).into_response()
+            }
+        }),
+    );
+
+    let (_unused_fallback_probe_url, fallback_probe_handle) = start_server(fallback_probe).await;
+    let gateway = build_router_with_state(AppState::new().expect("gateway should build"));
+    let (gateway_url, gateway_handle) = start_server(gateway).await;
+    let client = reqwest::Client::new();
+
+    let user_settings = json!({
+        "preferredModelId": "gemini-3.5-flash-low",
+        "theme": "dark"
+    });
+    let requests = vec![
+        (
+            "/v1internal:loadCodeAssist",
+            json!({"metadata": {"ideType": "ANTIGRAVITY_CLI"}}),
+        ),
+        (
+            "/v1internal:fetchAvailableModels",
+            json!({"project": "aether-antigravity-local"}),
+        ),
+        (
+            "/v1internal:fetchUserInfo",
+            json!({"project": "aether-antigravity-local"}),
+        ),
+        (
+            "/v1internal:fetchAdminControls",
+            json!({"project": "aether-antigravity-local"}),
+        ),
+        ("/v1internal:listExperiments", json!({})),
+        (
+            "/v1internal:recordCodeAssistMetrics",
+            json!({
+                "project": "aether-antigravity-local",
+                "requestId": "opaque-request-id",
+                "metrics": []
+            }),
+        ),
+        (
+            "/v1internal:setUserSettings",
+            json!({"userSettings": user_settings.clone()}),
+        ),
+    ];
+
+    for (path, request_body) in requests {
+        let response = client
+            .post(format!("{gateway_url}{path}"))
+            .header("authorization", "Bearer ant-access-token")
+            .header("user-agent", "antigravity/cli/1.0.2 linux/arm64")
+            .json(&request_body)
+            .send()
+            .await
+            .expect("request should succeed");
+
+        assert_eq!(response.status(), StatusCode::OK, "path {path}");
+        assert_eq!(
+            response
+                .headers()
+                .get(EXECUTION_PATH_HEADER)
+                .and_then(|value| value.to_str().ok()),
+            Some(EXECUTION_PATH_LOCAL_AI_PUBLIC),
+            "path {path}"
+        );
+        let payload: serde_json::Value = response.json().await.expect("json body should parse");
+
+        match path {
+            "/v1internal:loadCodeAssist" => {
+                assert_eq!(
+                    payload["cloudaicompanionProject"],
+                    "aether-antigravity-local"
+                );
+                assert_eq!(payload["currentTier"], "free");
+                assert_eq!(payload["paidTier"], false);
+                assert_eq!(payload["gcpManaged"], false);
+                assert_eq!(payload["allowedTiers"], json!(["free"]));
+                assert_eq!(payload["upgradeSubscriptionUri"], "");
+            }
+            "/v1internal:fetchAvailableModels" => {
+                assert_eq!(payload["defaultAgentModelId"], "gemini-3.5-flash-low");
+                assert_eq!(payload["tieredModelIds"]["flash"], "gemini-3-flash-agent");
+                assert_eq!(
+                    payload["models"]["gemini-3.5-flash-low"]["id"],
+                    "gemini-3.5-flash-low"
+                );
+                assert_eq!(payload["commandModelIds"], json!(["gemini-3-flash"]));
+                assert_eq!(
+                    payload["imageGenerationModelIds"],
+                    json!(["gemini-3.1-flash-image"])
+                );
+            }
+            "/v1internal:fetchUserInfo" => {
+                assert_eq!(payload["regionCode"], "US");
+                assert_eq!(
+                    payload["userSettings"]["preferredModelId"],
+                    "gemini-3.5-flash-low"
+                );
+            }
+            "/v1internal:fetchAdminControls" => {
+                assert_eq!(payload, json!({}));
+            }
+            "/v1internal:listExperiments" => {
+                assert_eq!(payload["experimentIds"], json!([]));
+                assert_eq!(payload["flags"], json!({}));
+            }
+            "/v1internal:recordCodeAssistMetrics" => {
+                assert_eq!(payload, json!({}));
+            }
+            "/v1internal:setUserSettings" => {
+                assert_eq!(payload["userSettings"], user_settings);
+            }
+            other => panic!("unexpected path {other}"),
+        }
+    }
+
+    assert_eq!(*fallback_probe_hits.lock().expect("mutex should lock"), 0);
+
+    gateway_handle.abort();
+    fallback_probe_handle.abort();
+}
+
 #[tokio::test]
 async fn gateway_does_not_locally_reject_image_model_name_on_chat_completions() {
     let fallback_probe_hits = Arc::new(Mutex::new(0usize));

apps/aether-gateway/src/tests/frontdoor/ops.rs

@@ -168,6 +168,15 @@ async fn gateway_exposes_frontdoor_manifest_without_proxying_upstream() {
     assert!(owned_routes
         .iter()
         .any(|value| value == "/v1beta/files/{path...}"));
+    assert!(owned_routes
+        .iter()
+        .any(|value| value == "/v1internal:loadCodeAssist"));
+    assert!(owned_routes
+        .iter()
+        .any(|value| value == "/v1internal:fetchAvailableModels"));
+    assert!(owned_routes
+        .iter()
+        .any(|value| value == "/v1internal:streamGenerateContent"));
     assert_eq!(
         payload["rust_frontdoor"]["internal_gateway"]["status"],
         "rust_native_control_plane"