optexity-browser-use 0.9.5__py3-none-any.whl

browser_use/llm/browser_use/chat.py

@@ -0,0 +1,201 @@
+"""
+ChatBrowserUse - Client for browser-use cloud API
+
+This wraps the BaseChatModel protocol and sends requests to the browser-use cloud API
+for optimized browser automation LLM inference.
+"""
+
+import logging
+import os
+from typing import TypeVar, overload
+
+import httpx
+from pydantic import BaseModel
+
+from browser_use.llm.base import BaseChatModel
+from browser_use.llm.messages import BaseMessage
+from browser_use.llm.views import ChatInvokeCompletion
+from browser_use.observability import observe
+
+T = TypeVar('T', bound=BaseModel)
+
+logger = logging.getLogger(__name__)
+
+
+class ChatBrowserUse(BaseChatModel):
+	"""
+	Client for browser-use cloud API.
+
+	This sends requests to the browser-use cloud API which uses optimized models
+	and prompts for browser automation tasks.
+
+	Usage:
+		agent = Agent(
+			task="Find the number of stars of the browser-use repo",
+			llm=ChatBrowserUse(model='bu-latest'),
+		)
+	"""
+
+	def __init__(
+		self,
+		model: str = 'bu-latest',
+		api_key: str | None = None,
+		base_url: str | None = None,
+		timeout: float = 120.0,
+		**kwargs,
+	):
+		"""
+		Initialize ChatBrowserUse client.
+
+		Args:
+			model: Model name to use. Options: 'bu-latest', 'bu-1-0'. Defaults to 'bu-latest'.
+			api_key: API key for browser-use cloud. Defaults to BROWSER_USE_API_KEY env var.
+			base_url: Base URL for the API. Defaults to BROWSER_USE_LLM_URL env var or production URL.
+			timeout: Request timeout in seconds.
+		"""
+		# Validate model name
+		valid_models = ['bu-latest', 'bu-1-0']
+		if model not in valid_models:
+			raise ValueError(f"Invalid model: '{model}'. Must be one of {valid_models}")
+
+		self.model = 'bu-1-0' if model == 'bu-latest' else model  # must update on new model releases
+		self.fast = False
+		self.api_key = api_key or os.getenv('BROWSER_USE_API_KEY')
+		self.base_url = base_url or os.getenv('BROWSER_USE_LLM_URL', 'https://llm.api.browser-use.com')
+		self.timeout = timeout
+
+		if not self.api_key:
+			raise ValueError(
+				'You need to set the BROWSER_USE_API_KEY environment variable. '
+				'Get your key at https://cloud.browser-use.com/new-api-key'
+			)
+
+	@property
+	def provider(self) -> str:
+		return 'browser-use'
+
+	@property
+	def name(self) -> str:
+		return self.model
+
+	@overload
+	async def ainvoke(
+		self, messages: list[BaseMessage], output_format: None = None, request_type: str = 'browser_agent'
+	) -> ChatInvokeCompletion[str]: ...
+
+	@overload
+	async def ainvoke(
+		self, messages: list[BaseMessage], output_format: type[T], request_type: str = 'browser_agent'
+	) -> ChatInvokeCompletion[T]: ...
+
+	@observe(name='chat_browser_use_ainvoke')
+	async def ainvoke(
+		self, messages: list[BaseMessage], output_format: type[T] | None = None, request_type: str = 'browser_agent'
+	) -> ChatInvokeCompletion[T] | ChatInvokeCompletion[str]:
+		"""
+		Send request to browser-use cloud API.
+
+		Args:
+			messages: List of messages to send
+			output_format: Expected output format (Pydantic model)
+			request_type: Type of request - 'browser_agent' or 'judge'
+
+		Returns:
+			ChatInvokeCompletion with structured response and usage info
+		"""
+		# Prepare request payload
+		payload = {
+			'messages': [self._serialize_message(msg) for msg in messages],
+			'fast': self.fast,
+			'request_type': request_type,
+		}
+
+		# Add output format schema if provided
+		if output_format is not None:
+			payload['output_format'] = output_format.model_json_schema()
+
+		# Make API request
+		async with httpx.AsyncClient(timeout=self.timeout) as client:
+			try:
+				response = await client.post(
+					f'{self.base_url}/v1/chat/completions',
+					json=payload,
+					headers={
+						'Authorization': f'Bearer {self.api_key}',
+						'Content-Type': 'application/json',
+					},
+				)
+				response.raise_for_status()
+				result = response.json()
+
+			except httpx.HTTPStatusError as e:
+				error_detail = ''
+				try:
+					error_data = e.response.json()
+					error_detail = error_data.get('detail', str(e))
+				except Exception:
+					error_detail = str(e)
+
+				error_msg = ''
+				if e.response.status_code == 401:
+					error_msg = f'Invalid API key. {error_detail}'
+				elif e.response.status_code == 402:
+					error_msg = f'Insufficient credits. {error_detail}'
+				else:
+					error_msg = f'API request failed: {error_detail}'
+
+				raise ValueError(error_msg)
+
+			except httpx.TimeoutException:
+				error_msg = f'Request timed out after {self.timeout}s'
+				raise ValueError(error_msg)
+
+			except Exception as e:
+				error_msg = f'Failed to connect to browser-use API: {e}'
+				raise ValueError(error_msg)
+
+			# Parse response - server returns structured data as dict
+			if output_format is not None:
+				# Server returns structured data as a dict, validate it
+				completion_data = result['completion']
+				logger.debug(
+					f'📥 Got structured data from service: {list(completion_data.keys()) if isinstance(completion_data, dict) else type(completion_data)}'
+				)
+
+				# Convert action dicts to ActionModel instances if needed
+				# llm-use returns dicts to avoid validation with empty ActionModel
+				if isinstance(completion_data, dict) and 'action' in completion_data:
+					actions = completion_data['action']
+					if actions and isinstance(actions[0], dict):
+						from typing import get_args
+
+						# Get ActionModel type from output_format
+						action_model_type = get_args(output_format.model_fields['action'].annotation)[0]
+
+						# Convert dicts to ActionModel instances
+						completion_data['action'] = [action_model_type.model_validate(action_dict) for action_dict in actions]
+
+				completion = output_format.model_validate(completion_data)
+			else:
+				completion = result['completion']
+
+			# Parse usage info
+			usage = None
+			if 'usage' in result:
+				from browser_use.llm.views import ChatInvokeUsage
+
+				usage = ChatInvokeUsage(**result['usage'])
+
+		return ChatInvokeCompletion(
+			completion=completion,
+			usage=usage,
+		)
+
+	def _serialize_message(self, message: BaseMessage) -> dict:
+		"""Serialize a message to JSON format."""
+		# Handle Union types by checking the actual message type
+		msg_dict = message.model_dump()
+		return {
+			'role': msg_dict['role'],
+			'content': msg_dict['content'],
+		}

browser_use/llm/cerebras/chat.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, TypeVar, overload
+
+import httpx
+from openai import (
+	APIConnectionError,
+	APIError,
+	APIStatusError,
+	APITimeoutError,
+	AsyncOpenAI,
+	RateLimitError,
+)
+from openai.types.chat import ChatCompletion
+from pydantic import BaseModel
+
+from browser_use.llm.base import BaseChatModel
+from browser_use.llm.cerebras.serializer import CerebrasMessageSerializer
+from browser_use.llm.exceptions import ModelProviderError, ModelRateLimitError
+from browser_use.llm.messages import BaseMessage
+from browser_use.llm.views import ChatInvokeCompletion, ChatInvokeUsage
+
+T = TypeVar('T', bound=BaseModel)
+
+
+@dataclass
+class ChatCerebras(BaseChatModel):
+	"""Cerebras inference wrapper (OpenAI-compatible)."""
+
+	model: str = 'llama3.1-8b'
+
+	# Generation parameters
+	max_tokens: int | None = 4096
+	temperature: float | None = 0.2
+	top_p: float | None = None
+	seed: int | None = None
+
+	# Connection parameters
+	api_key: str | None = None
+	base_url: str | httpx.URL | None = 'https://api.cerebras.ai/v1'
+	timeout: float | httpx.Timeout | None = None
+	client_params: dict[str, Any] | None = None
+
+	@property
+	def provider(self) -> str:
+		return 'cerebras'
+
+	def _client(self) -> AsyncOpenAI:
+		return AsyncOpenAI(
+			api_key=self.api_key,
+			base_url=self.base_url,
+			timeout=self.timeout,
+			**(self.client_params or {}),
+		)
+
+	@property
+	def name(self) -> str:
+		return self.model
+
+	def _get_usage(self, response: ChatCompletion) -> ChatInvokeUsage | None:
+		if response.usage is not None:
+			usage = ChatInvokeUsage(
+				prompt_tokens=response.usage.prompt_tokens,
+				prompt_cached_tokens=None,
+				prompt_cache_creation_tokens=None,
+				prompt_image_tokens=None,
+				completion_tokens=response.usage.completion_tokens,
+				total_tokens=response.usage.total_tokens,
+			)
+		else:
+			usage = None
+		return usage
+
+	@overload
+	async def ainvoke(
+		self,
+		messages: list[BaseMessage],
+		output_format: None = None,
+	) -> ChatInvokeCompletion[str]: ...
+
+	@overload
+	async def ainvoke(
+		self,
+		messages: list[BaseMessage],
+		output_format: type[T],
+	) -> ChatInvokeCompletion[T]: ...
+
+	async def ainvoke(
+		self,
+		messages: list[BaseMessage],
+		output_format: type[T] | None = None,
+	) -> ChatInvokeCompletion[T] | ChatInvokeCompletion[str]:
+		"""
+		Cerebras ainvoke supports:
+		1. Regular text/multi-turn conversation
+		2. JSON Output (response_format)
+		"""
+		client = self._client()
+		cerebras_messages = CerebrasMessageSerializer.serialize_messages(messages)
+		common: dict[str, Any] = {}
+
+		if self.temperature is not None:
+			common['temperature'] = self.temperature
+		if self.max_tokens is not None:
+			common['max_tokens'] = self.max_tokens
+		if self.top_p is not None:
+			common['top_p'] = self.top_p
+		if self.seed is not None:
+			common['seed'] = self.seed
+
+		# ① Regular multi-turn conversation/text output
+		if output_format is None:
+			try:
+				resp = await client.chat.completions.create(  # type: ignore
+					model=self.model,
+					messages=cerebras_messages,  # type: ignore
+					**common,
+				)
+				usage = self._get_usage(resp)
+				return ChatInvokeCompletion(
+					completion=resp.choices[0].message.content or '',
+					usage=usage,
+				)
+			except RateLimitError as e:
+				raise ModelRateLimitError(str(e), model=self.name) from e
+			except (APIError, APIConnectionError, APITimeoutError, APIStatusError) as e:
+				raise ModelProviderError(str(e), model=self.name) from e
+			except Exception as e:
+				raise ModelProviderError(str(e), model=self.name) from e
+
+		# ② JSON Output path (response_format)
+		if output_format is not None and hasattr(output_format, 'model_json_schema'):
+			try:
+				# For Cerebras, we'll use a simpler approach without response_format
+				# Instead, we'll ask the model to return JSON and parse it
+				import json
+
+				# Get the schema to guide the model
+				schema = output_format.model_json_schema()
+				schema_str = json.dumps(schema, indent=2)
+
+				# Create a prompt that asks for the specific JSON structure
+				json_prompt = f"""
+Please respond with a JSON object that follows this exact schema:
+{schema_str}
+
+Your response must be valid JSON only, no other text.
+"""
+
+				# Add or modify the last user message to include the JSON prompt
+				if cerebras_messages and cerebras_messages[-1]['role'] == 'user':
+					if isinstance(cerebras_messages[-1]['content'], str):
+						cerebras_messages[-1]['content'] += json_prompt
+					elif isinstance(cerebras_messages[-1]['content'], list):
+						cerebras_messages[-1]['content'].append({'type': 'text', 'text': json_prompt})
+				else:
+					# Add as a new user message
+					cerebras_messages.append({'role': 'user', 'content': json_prompt})
+
+				resp = await client.chat.completions.create(  # type: ignore
+					model=self.model,
+					messages=cerebras_messages,  # type: ignore
+					**common,
+				)
+				content = resp.choices[0].message.content
+				if not content:
+					raise ModelProviderError('Empty JSON content in Cerebras response', model=self.name)
+
+				usage = self._get_usage(resp)
+
+				# Try to extract JSON from the response
+				import re
+
+				json_match = re.search(r'\{.*\}', content, re.DOTALL)
+				if json_match:
+					json_str = json_match.group(0)
+				else:
+					json_str = content
+
+				parsed = output_format.model_validate_json(json_str)
+				return ChatInvokeCompletion(
+					completion=parsed,
+					usage=usage,
+				)
+			except RateLimitError as e:
+				raise ModelRateLimitError(str(e), model=self.name) from e
+			except (APIError, APIConnectionError, APITimeoutError, APIStatusError) as e:
+				raise ModelProviderError(str(e), model=self.name) from e
+			except Exception as e:
+				raise ModelProviderError(str(e), model=self.name) from e
+
+		raise ModelProviderError('No valid ainvoke execution path for Cerebras LLM', model=self.name)

browser_use/llm/cerebras/serializer.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import json
+from typing import Any, overload
+
+from browser_use.llm.messages import (
+	AssistantMessage,
+	BaseMessage,
+	ContentPartImageParam,
+	ContentPartTextParam,
+	SystemMessage,
+	ToolCall,
+	UserMessage,
+)
+
+MessageDict = dict[str, Any]
+
+
+class CerebrasMessageSerializer:
+	"""Serializer for converting browser-use messages to Cerebras messages."""
+
+	# -------- content 处理 --------------------------------------------------
+	@staticmethod
+	def _serialize_text_part(part: ContentPartTextParam) -> str:
+		return part.text
+
+	@staticmethod
+	def _serialize_image_part(part: ContentPartImageParam) -> dict[str, Any]:
+		url = part.image_url.url
+		if url.startswith('data:'):
+			return {'type': 'image_url', 'image_url': {'url': url}}
+		return {'type': 'image_url', 'image_url': {'url': url}}
+
+	@staticmethod
+	def _serialize_content(content: Any) -> str | list[dict[str, Any]]:
+		if content is None:
+			return ''
+		if isinstance(content, str):
+			return content
+		serialized: list[dict[str, Any]] = []
+		for part in content:
+			if part.type == 'text':
+				serialized.append({'type': 'text', 'text': CerebrasMessageSerializer._serialize_text_part(part)})
+			elif part.type == 'image_url':
+				serialized.append(CerebrasMessageSerializer._serialize_image_part(part))
+			elif part.type == 'refusal':
+				serialized.append({'type': 'text', 'text': f'[Refusal] {part.refusal}'})
+		return serialized
+
+	# -------- Tool-call 处理 -------------------------------------------------
+	@staticmethod
+	def _serialize_tool_calls(tool_calls: list[ToolCall]) -> list[dict[str, Any]]:
+		cerebras_tool_calls: list[dict[str, Any]] = []
+		for tc in tool_calls:
+			try:
+				arguments = json.loads(tc.function.arguments)
+			except json.JSONDecodeError:
+				arguments = {'arguments': tc.function.arguments}
+			cerebras_tool_calls.append(
+				{
+					'id': tc.id,
+					'type': 'function',
+					'function': {
+						'name': tc.function.name,
+						'arguments': arguments,
+					},
+				}
+			)
+		return cerebras_tool_calls
+
+	# -------- 单条消息序列化 -------------------------------------------------
+	@overload
+	@staticmethod
+	def serialize(message: UserMessage) -> MessageDict: ...
+
+	@overload
+	@staticmethod
+	def serialize(message: SystemMessage) -> MessageDict: ...
+
+	@overload
+	@staticmethod
+	def serialize(message: AssistantMessage) -> MessageDict: ...
+
+	@staticmethod
+	def serialize(message: BaseMessage) -> MessageDict:
+		if isinstance(message, UserMessage):
+			return {
+				'role': 'user',
+				'content': CerebrasMessageSerializer._serialize_content(message.content),
+			}
+		if isinstance(message, SystemMessage):
+			return {
+				'role': 'system',
+				'content': CerebrasMessageSerializer._serialize_content(message.content),
+			}
+		if isinstance(message, AssistantMessage):
+			msg: MessageDict = {
+				'role': 'assistant',
+				'content': CerebrasMessageSerializer._serialize_content(message.content),
+			}
+			if message.tool_calls:
+				msg['tool_calls'] = CerebrasMessageSerializer._serialize_tool_calls(message.tool_calls)
+			return msg
+		raise ValueError(f'Unknown message type: {type(message)}')
+
+	# -------- 列表序列化 -----------------------------------------------------
+	@staticmethod
+	def serialize_messages(messages: list[BaseMessage]) -> list[MessageDict]:
+		return [CerebrasMessageSerializer.serialize(m) for m in messages]