keenable web search: address review feedback

- Restrict retries to transient failures (429/5xx + network) via
  RetryableKeenableSearchError instead of retrying every Exception, so a
  bad API key (401/403) fails fast instead of 3x backoff.
- test_connection auth-error detection now keys off explicit status codes
  and "api key" (not the bare "api" substring, which matched api.keenable.ai
  in generic request errors); add a dedicated rate-limit branch.
- UI subtitle: "Keenable Search API" to match sibling providers.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: 2 people

backend/onyx/tools/tool_implementations/web_search/clients/keenable_client.py

@@ -1,7 +1,7 @@
 import json
+from typing import Any
 from urllib.parse import urlsplit
 
-
 import requests
 from fastapi import HTTPException
 
@@ -16,6 +16,10 @@
 KEENABLE_REQUEST_TIMEOUT_SECONDS = 30
 
 
+class RetryableKeenableSearchError(Exception):
+    """Error type used to trigger retry for transient Keenable search failures."""
+
+
 class KeenableClient(WebSearchProvider):
     """Keenable web search provider.
 
@@ -64,17 +68,34 @@ def _headers(self) -> dict[str, str]:
             headers["X-API-Key"] = self._api_key
         return headers
 
-    @retry_builder(tries=3, delay=1, backoff=2)
-    def search(self, query: str) -> list[WebSearchResult]:
+    @retry_builder(
+        tries=3,
+        delay=1,
+        backoff=2,
+        exceptions=(RetryableKeenableSearchError,),
+    )
+    def _search_with_retries(self, query: str) -> list[WebSearchResult]:
         # Keyless public endpoint by default; keyed endpoint when a key is set.
         path = "/v1/search" if self._api_key else "/v1/search/public"
-        response = requests.post(
-            f"{self._base_url}{path}",
-            headers=self._headers(),
-            data=json.dumps({"query": query, "mode": "pro"}),
-            timeout=KEENABLE_REQUEST_TIMEOUT_SECONDS,
-        )
-        response.raise_for_status()
+        try:
+            response = requests.post(
+                f"{self._base_url}{path}",
+                headers=self._headers(),
+                data=json.dumps({"query": query, "mode": "pro"}),
+                timeout=KEENABLE_REQUEST_TIMEOUT_SECONDS,
+            )
+        except requests.RequestException as exc:
+            raise RetryableKeenableSearchError(
+                f"Keenable search request failed: {exc}"
+            ) from exc
+
+        try:
+            response.raise_for_status()
+        except requests.HTTPError as exc:
+            error_msg = _build_error_message(response)
+            if _is_retryable_status(response.status_code):
+                raise RetryableKeenableSearchError(error_msg) from exc
+            raise ValueError(error_msg) from exc
 
         body = response.json()
         results = body.get("results") if isinstance(body, dict) else None
@@ -100,6 +121,12 @@ def search(self, query: str) -> list[WebSearchResult]:
 
         return validated_results
 
+    def search(self, query: str) -> list[WebSearchResult]:
+        try:
+            return self._search_with_retries(query)
+        except RetryableKeenableSearchError as exc:
+            raise ValueError(str(exc)) from exc
+
     def test_connection(self) -> dict[str, str]:
         try:
             test_results = self.search("test")
@@ -110,17 +137,62 @@ def test_connection(self) -> dict[str, str]:
                 )
         except HTTPException:
             raise
-        except Exception as e:
+        except (ValueError, requests.RequestException) as e:
             error_msg = str(e)
-            if any(t in error_msg.lower() for t in ("api", "key", "auth")):
+            lower = error_msg.lower()
+            if (
+                "status 401" in lower
+                or "status 403" in lower
+                or "api key" in lower
+                or "auth" in lower
+            ):
                 raise HTTPException(
                     status_code=400,
                     detail=f"Invalid Keenable API key: {error_msg}",
                 ) from e
+            if "status 429" in lower or "rate limit" in lower:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"Keenable rate limit exceeded: {error_msg}",
+                ) from e
             raise HTTPException(
                 status_code=400,
                 detail=f"Keenable validation failed: {error_msg}",
             ) from e
 
         logger.info("Web search provider test succeeded for Keenable.")
         return {"status": "ok"}
+
+
+def _build_error_message(response: requests.Response) -> str:
+    return (
+        f"Keenable search failed (status {response.status_code}): "
+        f"{_extract_error_detail(response)}"
+    )
+
+
+def _extract_error_detail(response: requests.Response) -> str:
+    try:
+        payload: Any = response.json()
+    except Exception:
+        text = response.text.strip()
+        return text[:200] if text else "No error details"
+
+    if isinstance(payload, dict):
+        error = payload.get("error")
+        if isinstance(error, dict):
+            detail = error.get("detail") or error.get("message")
+            if isinstance(detail, str):
+                return detail
+        if isinstance(error, str):
+            return error
+
+        message = payload.get("message") or payload.get("detail")
+        if isinstance(message, str):
+            return message
+
+    return str(payload)[:200]
+
+
+def _is_retryable_status(status_code: int) -> bool:
+    return status_code == 429 or status_code >= 500

web/src/lib/webSearch/utils.ts

@@ -71,7 +71,7 @@ export const SEARCH_PROVIDER_DETAILS: Record<
   },
   keenable: {
     label: "Keenable",
-    subtitle: "Keenable",
+    subtitle: "Keenable Search API",
     helper:
       "Connect to Keenable to set up web search. Works without an API key (keyless free tier); add a key to lift rate limits.",
     logo: SvgKeenable,