provider.py 4.3 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394
  1. """Keenable (https://keenable.ai) web search + fetch — keyless-ring member.
  2. Env: ``KEENABLE_API_KEY`` (optional; keyless free tier works without it).
  3. Config: ``web.provider_tier.keenable: free|paid`` pins the tier (unset = auto).
  4. """
  5. from __future__ import annotations
  6. import logging
  7. from typing import Any, Dict, List
  8. from agent.ssl_verify import requests_verify
  9. from plugins.web._common import (
  10. SEARCH_LIMIT_CAP, BaseWebSearchProvider, document, http_status_detail, keenable_origin_error, keyless_extract, keyless_search,
  11. keyless_variant_schema, page_error, provider_env, run_extract, run_search, search_fail, search_ok, use_keyless, web_hit,
  12. )
  13. logger = logging.getLogger(__name__)
  14. _KEENABLE_API_URL = "https://api.keenable.ai"
  15. def _keenable_headers(api_key: str) -> dict[str, str]:
  16. # The keyless tier structurally requires an app-identifier header; no user identifiers are sent.
  17. headers = {"X-Keenable-Title": "hermes-agent"}
  18. if api_key:
  19. headers["Authorization"] = f"Bearer {api_key}"
  20. return headers
  21. class KeenableWebSearchProvider(BaseWebSearchProvider):
  22. """Keenable search + extract provider (keyed or keyless)."""
  23. NAME = "keenable"
  24. DISPLAY_NAME = "Keenable"
  25. KEY_ENV = "KEENABLE_API_KEY"
  26. EXTRACT = True
  27. KEYLESS = True
  28. def search(self, query: str, limit: int = 5) -> dict[str, Any]:
  29. def _body() -> dict[str, Any]:
  30. api_key = provider_env("KEENABLE_API_KEY")
  31. if use_keyless("keenable", api_key):
  32. return keyless_search("Keenable", "keenable", query, limit, logger)
  33. import requests
  34. logger.info("Keenable search: '%s' (limit=%d)", query, limit)
  35. # requests freezes its default CA bundle path at its own import; a replaced
  36. # install environment leaves it dangling, so hand over a live bundle.
  37. response = requests.post(
  38. f"{_KEENABLE_API_URL}/v1/search",
  39. json={"query": query, "max_results": min(max(1, int(limit)), SEARCH_LIMIT_CAP)},
  40. headers=_keenable_headers(api_key), timeout=30, verify=requests_verify(),
  41. )
  42. if response.status_code >= 400:
  43. return search_fail(f"Keenable search failed: {http_status_detail(response)}")
  44. return search_ok([
  45. web_hit(r.get("url") or "", r.get("title") or "", r.get("snippet") or r.get("description") or "", i + 1)
  46. for i, r in enumerate(response.json().get("results") or [])
  47. ])
  48. return run_search("Keenable", logger, _body, verbatim_value_error=False)
  49. def extract(self, urls: list[str], **kwargs: Any) -> list[dict[str, Any]]:
  50. def _body() -> list[dict[str, Any]]:
  51. api_key = provider_env("KEENABLE_API_KEY")
  52. if use_keyless("keenable", api_key):
  53. return keyless_extract("Keenable", "keenable", urls, logger)
  54. import requests
  55. logger.info("Keenable extract: %d URL(s)", len(urls))
  56. results: list[dict[str, Any]] = []
  57. for url in urls:
  58. try:
  59. response = requests.get(f"{_KEENABLE_API_URL}/v1/fetch", params={"url": url}, headers=_keenable_headers(api_key), timeout=30, verify=requests_verify())
  60. if response.status_code >= 400:
  61. if origin := keenable_origin_error(response.status_code, response.text):
  62. results.append(page_error(url, origin))
  63. continue
  64. raise ValueError(http_status_detail(response))
  65. data = response.json()
  66. results.append(document(data.get("url") or url, data.get("title") or "", data.get("content") or "", source_url=url))
  67. except Exception as exc:
  68. results.append(page_error(url, f"Keenable extract failed: {exc}"))
  69. return results
  70. return run_extract("Keenable", logger, urls, _body, verbatim_value_error=False)
  71. def get_setup_schema(self) -> dict[str, Any]:
  72. return keyless_variant_schema(
  73. "Keenable", "KEENABLE_API_KEY", "https://keenable.ai",
  74. free_tag="Independent web index for AI apps — fast search + page fetch on Keenable's anonymous free tier.",
  75. paid_tag="Independent web index for AI apps. Keyed access with higher limits and guaranteed service.",
  76. )