provider.py 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160
  1. """Browser Use cloud browser provider — the only backend with dual auth: direct
  2. ``BROWSER_USE_API_KEY`` (https://browser-use.com) or the managed Nous tool gateway (bills to a
  3. Nous subscription). Direct first, managed second, unless ``tool_gateway.browser: gateway`` flips
  4. it. Config: ``browser.cloud_provider: "browser-use"``."""
  5. from __future__ import annotations
  6. import logging
  7. import threading
  8. import uuid
  9. from typing import Any, Dict, Optional
  10. import requests
  11. from agent.secret_scope import get_secret
  12. from plugins.browser._common import CloudBrowserProvider
  13. logger = logging.getLogger(__name__)
  14. # Managed-mode create idempotency keys: the gateway answers retried POSTs with 409 "already in
  15. # progress", so the original key is forwarded; cleared on success or terminal failure.
  16. _pending_create_keys: dict[str, str] = {}
  17. _pending_create_keys_lock = threading.Lock()
  18. _BASE_URL = "https://api.browser-use.com/api/v3"
  19. _DEFAULT_MANAGED_TIMEOUT_MINUTES = 5
  20. _DEFAULT_MANAGED_PROXY_COUNTRY_CODE = "us"
  21. def _get_or_create_pending_create_key(task_id: str) -> str:
  22. with _pending_create_keys_lock:
  23. existing = _pending_create_keys.get(task_id)
  24. if existing:
  25. return existing
  26. created = f"browser-use-session-create:{uuid.uuid4().hex}"
  27. _pending_create_keys[task_id] = created
  28. return created
  29. def _clear_pending_create_key(task_id: str) -> None:
  30. with _pending_create_keys_lock:
  31. _pending_create_keys.pop(task_id, None)
  32. def _should_preserve_pending_create_key(response: requests.Response) -> bool:
  33. """Keep the key when retryable: any 5xx, or a 409 saying the original request is still in
  34. flight. Other 4xx (auth, bad request) won't succeed on retry, so the key is dropped."""
  35. if response.status_code >= 500:
  36. return True
  37. if response.status_code != 409:
  38. return False
  39. try:
  40. payload = response.json()
  41. except Exception:
  42. return False
  43. error = payload.get("error") if isinstance(payload, dict) else None
  44. return isinstance(error, dict) and "already in progress" in str(error.get("message") or "").lower()
  45. class BrowserUseBrowserProvider(CloudBrowserProvider):
  46. """Browser Use (https://browser-use.com) cloud browser backend."""
  47. provider_id = "browser-use"
  48. label = "Browser Use"
  49. release_method = "patch"
  50. release_path = "/browsers/{session_id}"
  51. # Hidden from the picker; stays registered for the Nous gateway path and legacy cloud_provider
  52. # configs.
  53. setup_tag = None
  54. def is_available(self) -> bool:
  55. return self._get_config_or_none(refresh_token=False) is not None
  56. def _get_config_or_none(self, *, refresh_token: bool = True) -> Optional[dict[str, Any]]:
  57. # Lazy: managed_tool_gateway pulls in the Nous auth stack direct-key users never need.
  58. from tools.managed_tool_gateway import peek_nous_access_token, resolve_managed_tool_gateway
  59. from tools.tool_backend_helpers import NOUS_MANAGED_PROVIDER, read_selection
  60. def _managed_config() -> Optional[dict[str, Any]]:
  61. # Keep availability scans off the synchronous OAuth refresh path.
  62. managed = resolve_managed_tool_gateway(
  63. "browser-use", token_reader=None if refresh_token else peek_nous_access_token)
  64. if managed is None:
  65. return None
  66. return {
  67. "api_key": managed.nous_user_token,
  68. "base_url": managed.gateway_origin.rstrip("/"),
  69. "managed_mode": True,
  70. }
  71. api_key = get_secret("BROWSER_USE_API_KEY")
  72. selected = read_selection("browser")
  73. direct = {"api_key": api_key, "base_url": _BASE_URL, "managed_mode": False}
  74. # Strict: "nous" (or legacy use_gateway: true) → managed ONLY; any other stored selection →
  75. # direct ONLY (no silent managed fallback); never-configured → direct if present, else managed.
  76. if selected == NOUS_MANAGED_PROVIDER:
  77. return _managed_config()
  78. if selected is not None:
  79. return direct if api_key else None
  80. return direct if api_key else _managed_config()
  81. def _get_config(self) -> dict[str, Any]:
  82. from tools.tool_backend_helpers import (
  83. NOUS_MANAGED_PROVIDER, managed_nous_tools_enabled, read_selection, selection_error)
  84. config = self._get_config_or_none()
  85. if config is not None:
  86. return config
  87. selected = read_selection("browser")
  88. if selected == NOUS_MANAGED_PROVIDER:
  89. raise ValueError(selection_error(
  90. "browser", NOUS_MANAGED_PROVIDER,
  91. "the Nous Tool Gateway is not available (not entitled or unreachable)"))
  92. if selected is not None:
  93. raise ValueError(selection_error("browser", selected, "BROWSER_USE_API_KEY is not set"))
  94. if managed_nous_tools_enabled():
  95. raise ValueError(
  96. "Browser Use requires either a direct BROWSER_USE_API_KEY "
  97. "credential or a managed Browser Use gateway configuration.")
  98. raise ValueError("Browser Use requires a direct BROWSER_USE_API_KEY credential.")
  99. def _headers(self, config: dict[str, Any]) -> dict[str, str]:
  100. return {"Content-Type": "application/json", "X-Browser-Use-API-Key": config["api_key"]}
  101. def _release_body(self, config: dict[str, Any]) -> dict[str, object]:
  102. return {"action": "stop"}
  103. def create_session(self, task_id: str) -> dict[str, object]:
  104. config = self._get_config()
  105. managed_mode = bool(config.get("managed_mode"))
  106. headers = self._headers(config)
  107. if managed_mode:
  108. headers["X-Idempotency-Key"] = _get_or_create_pending_create_key(task_id)
  109. # Short gateway sessions: billing authorization must not default to a long Browser-Use timeout.
  110. payload = (
  111. {"timeout": _DEFAULT_MANAGED_TIMEOUT_MINUTES, "proxyCountryCode": _DEFAULT_MANAGED_PROXY_COUNTRY_CODE}
  112. if managed_mode else {})
  113. # Managed mode propagates network errors raw (retry with the preserved key); direct wraps them.
  114. response = self._post_create(
  115. f"{config['base_url']}/browsers", headers, payload, wrap_errors=not managed_mode)
  116. if not response.ok and managed_mode and not _should_preserve_pending_create_key(response):
  117. _clear_pending_create_key(task_id)
  118. self._check_created(response)
  119. session_data = response.json()
  120. if managed_mode:
  121. _clear_pending_create_key(task_id)
  122. session_name = self._session_name(task_id)
  123. logger.info("Created Browser Use session %s", session_name)
  124. return {
  125. "session_name": session_name,
  126. "bb_session_id": session_data["id"],
  127. "cdp_url": session_data.get("cdpUrl") or session_data.get("connectUrl") or "",
  128. # Fixed server-side lifetime: keep the API's authority so an expired CDP endpoint is retired.
  129. "expires_at": session_data.get("timeoutAt"),
  130. "features": {"browser_use": True},
  131. "external_call_id": response.headers.get("x-external-call-id") if managed_mode else None,
  132. }