fix: remove calls to non-existent fetchAvailableModels API

Updated health check and model discovery to use loadCodeAssist and hardcoded model lists respectively, avoiding 404 errors on standard Code Assist API endpoints.

Author: Mateusz

src/connectors/gemini_base/health_check_service.py

@@ -102,104 +102,75 @@ async def ensure_healthy(self) -> None:
                 self._backend_name,
             )
 
-    async def _perform_health_check(self) -> bool:
-        """Perform a health check by testing API connectivity.
-
-        This method tests actual API connectivity by making a simple request to verify
-        the OAuth token works and the service is accessible.
-
-        Uses the fetchAvailableModels endpoint which is supported by all Code Assist API
-        variants (standard and sandbox).
-
-        Returns:
-            bool: True if health check passes, False otherwise
-        """
-        try:
-            # Ensure credentials are available
-            credentials = self._credential_coordinator.credentials
+    async def _perform_health_check(self) -> bool:
+        """Perform a health check by testing API connectivity.
+
+        This method tests actual API connectivity by making a simple request to verify
+        the OAuth token works and the service is accessible.
+
+        Uses the loadCodeAssist endpoint which is supported by all Code Assist API
+        variants (standard and sandbox).
+        """
+        try:
+            # Ensure credentials are available
+            credentials = self._credential_coordinator.credentials
             if not credentials or not credentials.access_token:
                 if logger.isEnabledFor(logging.WARNING):
                     logger.warning(
                         "Health check failed for %s - no access token available",
                         self._backend_name,
                     )
-                return False
-
-            # Get base URL and headers from endpoint config
-            base_url = self._endpoint_config.get_base_url().rstrip("/")
-            headers = self._endpoint_config.get_api_headers(credentials.to_dict())
-
-            # Use fetchAvailableModels endpoint for health check
-            # This endpoint is supported by all Code Assist API variants
-            fetch_models_url = f"{base_url}/v1internal:fetchAvailableModels"
-            try:
-                response = await self._http_client.get(
-                    fetch_models_url, headers=headers, timeout=10.0
-                )
-            except httpx.TimeoutException as te:
-                logger.error(
-                    f"Health check timeout calling {fetch_models_url} for {self._backend_name}: {te}",
-                    exc_info=True,
-                )
-                return False
-            except httpx.RequestError as rexc:
-                logger.error(
-                    f"Health check connection error calling {fetch_models_url} for {self._backend_name}: {rexc}",
-                    exc_info=True,
-                )
-                return False
-
-            if response.status_code == 200:
-                if logger.isEnabledFor(logging.INFO):
-                    logger.info(
-                        "Health check passed for %s - API connectivity verified via fetchAvailableModels",
-                        self._backend_name,
-                    )
-                return True
-
-            # Fallback: use loadCodeAssist which is reliable on Code Assist API
-            load_url = f"{base_url}/v1internal:loadCodeAssist"
-            payload = {
-                "metadata": {
-                    "ideType": "IDE_UNSPECIFIED",
-                    "platform": "PLATFORM_UNSPECIFIED",
-                    "pluginType": "GEMINI",
-                }
-            }
-            try:
-                response = await self._http_client.post(
-                    load_url, headers=headers, json=payload, timeout=10.0
-                )
-            except httpx.TimeoutException as te:
-                logger.error(
-                    f"Health check timeout calling {load_url} for {self._backend_name}: {te}",
-                    exc_info=True,
-                )
-                return False
-            except httpx.RequestError as rexc:
-                logger.error(
-                    f"Health check connection error calling {load_url} for {self._backend_name}: {rexc}",
-                    exc_info=True,
-                )
-                return False
-
+                return False
+
+            # Get base URL and headers from endpoint config
+            base_url = self._endpoint_config.get_base_url().rstrip("/")
+            headers = self._endpoint_config.get_api_headers(credentials.to_dict())
+
+            # Use loadCodeAssist for health check - it's reliable and supported by all variants.
+            # We skip fetchAvailableModels as it is deprecated/non-existent on some endpoints.
+            load_url = f"{base_url}/v1internal:loadCodeAssist"
+            payload = {
+                "metadata": {
+                    "ideType": "IDE_UNSPECIFIED",
+                    "platform": "PLATFORM_UNSPECIFIED",
+                    "pluginType": "GEMINI",
+                }
+            }
+            try:
+                response = await self._http_client.post(
+                    load_url, headers=headers, json=payload, timeout=10.0
+                )
+            except httpx.TimeoutException as te:
+                logger.error(
+                    f"Health check timeout calling {load_url} for {self._backend_name}: {te}",
+                    exc_info=True,
+                )
+                return False
+            except httpx.RequestError as rexc:
+                logger.error(
+                    f"Health check connection error calling {load_url} for {self._backend_name}: {rexc}",
+                    exc_info=True,
+                )
+                return False
+
             if response.status_code == 200:
                 if logger.isEnabledFor(logging.INFO):
                     logger.info(
                         "Health check passed for %s via loadCodeAssist",
                         self._backend_name,
                     )
-                return True
-
+                return True
+
             if logger.isEnabledFor(logging.WARNING):
                 logger.warning(
                     "Health check failed for %s - API returned status %s",
                     self._backend_name,
                     response.status_code,
                 )
-            return False
-
-        except AuthenticationError as e:
+            return False
+
+        except AuthenticationError as e:
+
             logger.error(
                 f"Health check failed for {self._backend_name} - authentication error: {e}",
                 exc_info=True,

src/connectors/gemini_base/model_discovery.py

@@ -43,68 +43,37 @@ def get_fallback_models(self) -> list[str]:
         """
         return self._fallback_models.copy()
 
-    async def discover(
-        self,
-        client: "httpx.AsyncClient",
-        headers: dict[str, str],
-        base_url: str,
-    ) -> list[str]:
-        """Discover available models from fetchAvailableModels API.
-
-        Uses the v1internal:fetchAvailableModels endpoint which returns a dictionary
-        of available models. The models are extracted from the "models" dictionary keys
-        in the response.
-
-        Args:
-            client: The HTTP client for API calls.
-            headers: HTTP headers including authorization.
-            base_url: The API base URL.
-
-        Returns:
-            List of available model names.
-        """
-        if self._cached_models:
-            return self._cached_models.copy()
-
-        base_url = (base_url or "").rstrip("/")
-        url = f"{base_url}/v1internal:fetchAvailableModels"
-
-        try:
-            response = await client.get(url, headers=headers, timeout=15.0)
-        except Exception as exc:
-            logger.warning(
-                "Failed to reach fetchAvailableModels endpoint %s: %s",
-                url,
-                exc,
-                exc_info=True,
-            )
-            return self.get_fallback_models()
-
-        if response.status_code != 200:
-            logger.debug(
-                "fetchAvailableModels endpoint %s returned %s: %s",
-                url,
-                response.status_code,
-                response.text[:200] if response.text else "",
-            )
-            return self.get_fallback_models()
-
-        try:
-            data = response.json()
-            models = self._extract_models_from_response(data)
-            if models:
-                self._cached_models = models
-                logger.info(
-                    "Successfully discovered %d models from fetchAvailableModels",
-                    len(models),
-                )
-                return models
-        except Exception as exc:
-            logger.warning(
-                "Failed to parse fetchAvailableModels response: %s", exc, exc_info=True
-            )
-
-        return self.get_fallback_models()
+    async def discover(
+        self,
+        client: "httpx.AsyncClient",
+        headers: dict[str, str],
+        base_url: str,
+    ) -> list[str]:
+        """Return hardcoded model list (API discovery is deprecated).
+
+        The v1internal:fetchAvailableModels endpoint is no longer supported on
+        standard Code Assist API endpoints. This method now returns the hardcoded
+        fallback list to avoid 404 errors.
+
+        Args:
+            client: The HTTP client (unused).
+            headers: HTTP headers (unused).
+            base_url: The API base URL (unused).
+
+        Returns:
+            List of available model names.
+        """
+        if self._cached_models:
+            return self._cached_models.copy()
+
+        if logger.isEnabledFor(logging.INFO):
+            logger.info(
+                "Skipping fetchAvailableModels API (deprecated); using hardcoded model list."
+            )
+
+        self._cached_models = self.get_fallback_models()
+        return self._cached_models.copy()
+
 
     def _extract_models_from_response(self, data: dict[str, Any]) -> list[str]:
         """Extract model names from the API response.