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

browser_use/integrations/gmail/service.py

@@ -0,0 +1,225 @@
+"""
+Gmail API Service for Browser Use
+Handles Gmail API authentication, email reading, and 2FA code extraction.
+This service provides a clean interface for agents to interact with Gmail.
+"""
+
+import base64
+import logging
+import os
+from pathlib import Path
+from typing import Any
+
+import anyio
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+
+from browser_use.config import CONFIG
+
+logger = logging.getLogger(__name__)
+
+
+class GmailService:
+	"""
+	Gmail API service for email reading.
+	Provides functionality to:
+	- Authenticate with Gmail API using OAuth2
+	- Read recent emails with filtering
+	- Return full email content for agent analysis
+	"""
+
+	# Gmail API scopes
+	SCOPES = ['https://www.googleapis.com/auth/gmail.readonly']
+
+	def __init__(
+		self,
+		credentials_file: str | None = None,
+		token_file: str | None = None,
+		config_dir: str | None = None,
+		access_token: str | None = None,
+	):
+		"""
+		Initialize Gmail Service
+		Args:
+		    credentials_file: Path to OAuth credentials JSON from Google Cloud Console
+		    token_file: Path to store/load access tokens
+		    config_dir: Directory to store config files (defaults to browser-use config directory)
+		    access_token: Direct access token (skips file-based auth if provided)
+		"""
+		# Set up configuration directory using browser-use's config system
+		if config_dir is None:
+			self.config_dir = CONFIG.BROWSER_USE_CONFIG_DIR
+		else:
+			self.config_dir = Path(config_dir).expanduser().resolve()
+
+		# Ensure config directory exists (only if not using direct token)
+		if access_token is None:
+			self.config_dir.mkdir(parents=True, exist_ok=True)
+
+		# Set up credential paths
+		self.credentials_file = credentials_file or self.config_dir / 'gmail_credentials.json'
+		self.token_file = token_file or self.config_dir / 'gmail_token.json'
+
+		# Direct access token support
+		self.access_token = access_token
+
+		self.service = None
+		self.creds = None
+		self._authenticated = False
+
+	def is_authenticated(self) -> bool:
+		"""Check if Gmail service is authenticated"""
+		return self._authenticated and self.service is not None
+
+	async def authenticate(self) -> bool:
+		"""
+		Handle OAuth authentication and token management
+		Returns:
+		    bool: True if authentication successful, False otherwise
+		"""
+		try:
+			logger.info('🔐 Authenticating with Gmail API...')
+
+			# Check if using direct access token
+			if self.access_token:
+				logger.info('🔑 Using provided access token')
+				# Create credentials from access token
+				self.creds = Credentials(token=self.access_token, scopes=self.SCOPES)
+				# Test token validity by building service
+				self.service = build('gmail', 'v1', credentials=self.creds)
+				self._authenticated = True
+				logger.info('✅ Gmail API ready with access token!')
+				return True
+
+			# Original file-based authentication flow
+			# Try to load existing tokens
+			if os.path.exists(self.token_file):
+				self.creds = Credentials.from_authorized_user_file(str(self.token_file), self.SCOPES)
+				logger.debug('📁 Loaded existing tokens')
+
+			# If no valid credentials, run OAuth flow
+			if not self.creds or not self.creds.valid:
+				if self.creds and self.creds.expired and self.creds.refresh_token:
+					logger.info('🔄 Refreshing expired tokens...')
+					self.creds.refresh(Request())
+				else:
+					logger.info('🌐 Starting OAuth flow...')
+					if not os.path.exists(self.credentials_file):
+						logger.error(
+							f'❌ Gmail credentials file not found: {self.credentials_file}\n'
+							'Please download it from Google Cloud Console:\n'
+							'1. Go to https://console.cloud.google.com/\n'
+							'2. APIs & Services > Credentials\n'
+							'3. Download OAuth 2.0 Client JSON\n'
+							f"4. Save as 'gmail_credentials.json' in {self.config_dir}/"
+						)
+						return False
+
+					flow = InstalledAppFlow.from_client_secrets_file(str(self.credentials_file), self.SCOPES)
+					# Use specific redirect URI to match OAuth credentials
+					self.creds = flow.run_local_server(port=8080, open_browser=True)
+
+				# Save tokens for next time
+				await anyio.Path(self.token_file).write_text(self.creds.to_json())
+				logger.info(f'💾 Tokens saved to {self.token_file}')
+
+			# Build Gmail service
+			self.service = build('gmail', 'v1', credentials=self.creds)
+			self._authenticated = True
+			logger.info('✅ Gmail API ready!')
+			return True
+
+		except Exception as e:
+			logger.error(f'❌ Gmail authentication failed: {e}')
+			return False
+
+	async def get_recent_emails(self, max_results: int = 10, query: str = '', time_filter: str = '1h') -> list[dict[str, Any]]:
+		"""
+		Get recent emails with optional query filter
+		Args:
+		    max_results: Maximum number of emails to fetch
+		    query: Gmail search query (e.g., 'from:noreply@example.com')
+		    time_filter: Time filter (e.g., '5m', '1h', '1d')
+		Returns:
+		    List of email dictionaries with parsed content
+		"""
+		if not self.is_authenticated():
+			logger.error('❌ Gmail service not authenticated. Call authenticate() first.')
+			return []
+
+		try:
+			# Add time filter to query if provided
+			if time_filter and 'newer_than:' not in query:
+				query = f'newer_than:{time_filter} {query}'.strip()
+
+			logger.info(f'📧 Fetching {max_results} recent emails...')
+			if query:
+				logger.debug(f'🔍 Query: {query}')
+
+			# Get message list
+			assert self.service is not None
+			results = self.service.users().messages().list(userId='me', maxResults=max_results, q=query).execute()
+
+			messages = results.get('messages', [])
+			if not messages:
+				logger.info('📭 No messages found')
+				return []
+
+			logger.info(f'📨 Found {len(messages)} messages, fetching details...')
+
+			# Get full message details
+			emails = []
+			for i, message in enumerate(messages, 1):
+				logger.debug(f'📖 Reading email {i}/{len(messages)}...')
+
+				full_message = self.service.users().messages().get(userId='me', id=message['id'], format='full').execute()
+
+				email_data = self._parse_email(full_message)
+				emails.append(email_data)
+
+			return emails
+
+		except HttpError as error:
+			logger.error(f'❌ Gmail API error: {error}')
+			return []
+		except Exception as e:
+			logger.error(f'❌ Unexpected error fetching emails: {e}')
+			return []
+
+	def _parse_email(self, message: dict[str, Any]) -> dict[str, Any]:
+		"""Parse Gmail message into readable format"""
+		headers = {h['name']: h['value'] for h in message['payload']['headers']}
+
+		return {
+			'id': message['id'],
+			'thread_id': message['threadId'],
+			'subject': headers.get('Subject', ''),
+			'from': headers.get('From', ''),
+			'to': headers.get('To', ''),
+			'date': headers.get('Date', ''),
+			'timestamp': int(message['internalDate']),
+			'body': self._extract_body(message['payload']),
+			'raw_message': message,
+		}
+
+	def _extract_body(self, payload: dict[str, Any]) -> str:
+		"""Extract email body from payload"""
+		body = ''
+
+		if payload.get('body', {}).get('data'):
+			# Simple email body
+			body = base64.urlsafe_b64decode(payload['body']['data']).decode('utf-8')
+		elif payload.get('parts'):
+			# Multi-part email
+			for part in payload['parts']:
+				if part['mimeType'] == 'text/plain' and part.get('body', {}).get('data'):
+					part_body = base64.urlsafe_b64decode(part['body']['data']).decode('utf-8')
+					body += part_body
+				elif part['mimeType'] == 'text/html' and not body and part.get('body', {}).get('data'):
+					# Fallback to HTML if no plain text
+					body = base64.urlsafe_b64decode(part['body']['data']).decode('utf-8')
+
+		return body

browser_use/llm/__init__.py

@@ -0,0 +1,155 @@
+"""
+We have switched all of our code from langchain to openai.types.chat.chat_completion_message_param.
+
+For easier transition we have
+"""
+
+from typing import TYPE_CHECKING
+
+# Lightweight imports that are commonly used
+from browser_use.llm.base import BaseChatModel
+from browser_use.llm.messages import (
+	AssistantMessage,
+	BaseMessage,
+	SystemMessage,
+	UserMessage,
+)
+from browser_use.llm.messages import (
+	ContentPartImageParam as ContentImage,
+)
+from browser_use.llm.messages import (
+	ContentPartRefusalParam as ContentRefusal,
+)
+from browser_use.llm.messages import (
+	ContentPartTextParam as ContentText,
+)
+
+# Type stubs for lazy imports
+if TYPE_CHECKING:
+	from browser_use.llm.anthropic.chat import ChatAnthropic
+	from browser_use.llm.aws.chat_anthropic import ChatAnthropicBedrock
+	from browser_use.llm.aws.chat_bedrock import ChatAWSBedrock
+	from browser_use.llm.azure.chat import ChatAzureOpenAI
+	from browser_use.llm.browser_use.chat import ChatBrowserUse
+	from browser_use.llm.cerebras.chat import ChatCerebras
+	from browser_use.llm.deepseek.chat import ChatDeepSeek
+	from browser_use.llm.google.chat import ChatGoogle
+	from browser_use.llm.groq.chat import ChatGroq
+	from browser_use.llm.oci_raw.chat import ChatOCIRaw
+	from browser_use.llm.ollama.chat import ChatOllama
+	from browser_use.llm.openai.chat import ChatOpenAI
+	from browser_use.llm.openrouter.chat import ChatOpenRouter
+
+	# Type stubs for model instances - enables IDE autocomplete
+	openai_gpt_4o: ChatOpenAI
+	openai_gpt_4o_mini: ChatOpenAI
+	openai_gpt_4_1_mini: ChatOpenAI
+	openai_o1: ChatOpenAI
+	openai_o1_mini: ChatOpenAI
+	openai_o1_pro: ChatOpenAI
+	openai_o3: ChatOpenAI
+	openai_o3_mini: ChatOpenAI
+	openai_o3_pro: ChatOpenAI
+	openai_o4_mini: ChatOpenAI
+	openai_gpt_5: ChatOpenAI
+	openai_gpt_5_mini: ChatOpenAI
+	openai_gpt_5_nano: ChatOpenAI
+
+	azure_gpt_4o: ChatAzureOpenAI
+	azure_gpt_4o_mini: ChatAzureOpenAI
+	azure_gpt_4_1_mini: ChatAzureOpenAI
+	azure_o1: ChatAzureOpenAI
+	azure_o1_mini: ChatAzureOpenAI
+	azure_o1_pro: ChatAzureOpenAI
+	azure_o3: ChatAzureOpenAI
+	azure_o3_mini: ChatAzureOpenAI
+	azure_o3_pro: ChatAzureOpenAI
+	azure_gpt_5: ChatAzureOpenAI
+	azure_gpt_5_mini: ChatAzureOpenAI
+
+	google_gemini_2_0_flash: ChatGoogle
+	google_gemini_2_0_pro: ChatGoogle
+	google_gemini_2_5_pro: ChatGoogle
+	google_gemini_2_5_flash: ChatGoogle
+	google_gemini_2_5_flash_lite: ChatGoogle
+
+# Models are imported on-demand via __getattr__
+
+# Lazy imports mapping for heavy chat models
+_LAZY_IMPORTS = {
+	'ChatAnthropic': ('browser_use.llm.anthropic.chat', 'ChatAnthropic'),
+	'ChatAnthropicBedrock': ('browser_use.llm.aws.chat_anthropic', 'ChatAnthropicBedrock'),
+	'ChatAWSBedrock': ('browser_use.llm.aws.chat_bedrock', 'ChatAWSBedrock'),
+	'ChatAzureOpenAI': ('browser_use.llm.azure.chat', 'ChatAzureOpenAI'),
+	'ChatBrowserUse': ('browser_use.llm.browser_use.chat', 'ChatBrowserUse'),
+	'ChatCerebras': ('browser_use.llm.cerebras.chat', 'ChatCerebras'),
+	'ChatDeepSeek': ('browser_use.llm.deepseek.chat', 'ChatDeepSeek'),
+	'ChatGoogle': ('browser_use.llm.google.chat', 'ChatGoogle'),
+	'ChatGroq': ('browser_use.llm.groq.chat', 'ChatGroq'),
+	'ChatOCIRaw': ('browser_use.llm.oci_raw.chat', 'ChatOCIRaw'),
+	'ChatOllama': ('browser_use.llm.ollama.chat', 'ChatOllama'),
+	'ChatOpenAI': ('browser_use.llm.openai.chat', 'ChatOpenAI'),
+	'ChatOpenRouter': ('browser_use.llm.openrouter.chat', 'ChatOpenRouter'),
+}
+
+# Cache for model instances - only created when accessed
+_model_cache: dict[str, 'BaseChatModel'] = {}
+
+
+def __getattr__(name: str):
+	"""Lazy import mechanism for heavy chat model imports and model instances."""
+	if name in _LAZY_IMPORTS:
+		module_path, attr_name = _LAZY_IMPORTS[name]
+		try:
+			from importlib import import_module
+
+			module = import_module(module_path)
+			attr = getattr(module, attr_name)
+			return attr
+		except ImportError as e:
+			raise ImportError(f'Failed to import {name} from {module_path}: {e}') from e
+
+	# Check cache first for model instances
+	if name in _model_cache:
+		return _model_cache[name]
+
+	# Try to get model instances from models module on-demand
+	try:
+		from browser_use.llm.models import __getattr__ as models_getattr
+
+		attr = models_getattr(name)
+		# Cache in our clean cache dict
+		_model_cache[name] = attr
+		return attr
+	except (AttributeError, ImportError):
+		pass
+
+	raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+
+__all__ = [
+	# Message types -> for easier transition from langchain
+	'BaseMessage',
+	'UserMessage',
+	'SystemMessage',
+	'AssistantMessage',
+	# Content parts with better names
+	'ContentText',
+	'ContentRefusal',
+	'ContentImage',
+	# Chat models
+	'BaseChatModel',
+	'ChatOpenAI',
+	'ChatBrowserUse',
+	'ChatDeepSeek',
+	'ChatGoogle',
+	'ChatAnthropic',
+	'ChatAnthropicBedrock',
+	'ChatAWSBedrock',
+	'ChatGroq',
+	'ChatAzureOpenAI',
+	'ChatOCIRaw',
+	'ChatOllama',
+	'ChatOpenRouter',
+	'ChatCerebras',
+]

browser_use/llm/anthropic/chat.py

@@ -0,0 +1,242 @@
+import json
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any, TypeVar, overload
+
+import httpx
+from anthropic import (
+	APIConnectionError,
+	APIStatusError,
+	AsyncAnthropic,
+	NotGiven,
+	RateLimitError,
+	omit,
+)
+from anthropic.types import CacheControlEphemeralParam, Message, ToolParam
+from anthropic.types.model_param import ModelParam
+from anthropic.types.text_block import TextBlock
+from anthropic.types.tool_choice_tool_param import ToolChoiceToolParam
+from httpx import Timeout
+from pydantic import BaseModel
+
+from browser_use.llm.anthropic.serializer import AnthropicMessageSerializer
+from browser_use.llm.base import BaseChatModel
+from browser_use.llm.exceptions import ModelProviderError, ModelRateLimitError
+from browser_use.llm.messages import BaseMessage
+from browser_use.llm.schema import SchemaOptimizer
+from browser_use.llm.views import ChatInvokeCompletion, ChatInvokeUsage
+
+T = TypeVar('T', bound=BaseModel)
+
+
+@dataclass
+class ChatAnthropic(BaseChatModel):
+	"""
+	A wrapper around Anthropic's chat model.
+	"""
+
+	# Model configuration
+	model: str | ModelParam
+	max_tokens: int = 8192
+	temperature: float | None = None
+	top_p: float | None = None
+	seed: int | None = None
+
+	# Client initialization parameters
+	api_key: str | None = None
+	auth_token: str | None = None
+	base_url: str | httpx.URL | None = None
+	timeout: float | Timeout | None | NotGiven = NotGiven()
+	max_retries: int = 10
+	default_headers: Mapping[str, str] | None = None
+	default_query: Mapping[str, object] | None = None
+
+	# Static
+	@property
+	def provider(self) -> str:
+		return 'anthropic'
+
+	def _get_client_params(self) -> dict[str, Any]:
+		"""Prepare client parameters dictionary."""
+		# Define base client params
+		base_params = {
+			'api_key': self.api_key,
+			'auth_token': self.auth_token,
+			'base_url': self.base_url,
+			'timeout': self.timeout,
+			'max_retries': self.max_retries,
+			'default_headers': self.default_headers,
+			'default_query': self.default_query,
+		}
+
+		# Create client_params dict with non-None values and non-NotGiven values
+		client_params = {}
+		for k, v in base_params.items():
+			if v is not None and v is not NotGiven():
+				client_params[k] = v
+
+		return client_params
+
+	def _get_client_params_for_invoke(self):
+		"""Prepare client parameters dictionary for invoke."""
+
+		client_params = {}
+
+		if self.temperature is not None:
+			client_params['temperature'] = self.temperature
+
+		if self.max_tokens is not None:
+			client_params['max_tokens'] = self.max_tokens
+
+		if self.top_p is not None:
+			client_params['top_p'] = self.top_p
+
+		if self.seed is not None:
+			client_params['seed'] = self.seed
+
+		return client_params
+
+	def get_client(self) -> AsyncAnthropic:
+		"""
+		Returns an AsyncAnthropic client.
+
+		Returns:
+			AsyncAnthropic: An instance of the AsyncAnthropic client.
+		"""
+		client_params = self._get_client_params()
+		return AsyncAnthropic(**client_params)
+
+	@property
+	def name(self) -> str:
+		return str(self.model)
+
+	def _get_usage(self, response: Message) -> ChatInvokeUsage | None:
+		usage = ChatInvokeUsage(
+			prompt_tokens=response.usage.input_tokens
+			+ (
+				response.usage.cache_read_input_tokens or 0
+			),  # Total tokens in Anthropic are a bit fucked, you have to add cached tokens to the prompt tokens
+			completion_tokens=response.usage.output_tokens,
+			total_tokens=response.usage.input_tokens + response.usage.output_tokens,
+			prompt_cached_tokens=response.usage.cache_read_input_tokens,
+			prompt_cache_creation_tokens=response.usage.cache_creation_input_tokens,
+			prompt_image_tokens=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]:
+		anthropic_messages, system_prompt = AnthropicMessageSerializer.serialize_messages(messages)
+
+		try:
+			if output_format is None:
+				# Normal completion without structured output
+				response = await self.get_client().messages.create(
+					model=self.model,
+					messages=anthropic_messages,
+					system=system_prompt or omit,
+					**self._get_client_params_for_invoke(),
+				)
+
+				# Ensure we have a valid Message object before accessing attributes
+				if not isinstance(response, Message):
+					raise ModelProviderError(
+						message=f'Unexpected response type from Anthropic API: {type(response).__name__}. Response: {str(response)[:200]}',
+						status_code=502,
+						model=self.name,
+					)
+
+				usage = self._get_usage(response)
+
+				# Extract text from the first content block
+				first_content = response.content[0]
+				if isinstance(first_content, TextBlock):
+					response_text = first_content.text
+				else:
+					# If it's not a text block, convert to string
+					response_text = str(first_content)
+
+				return ChatInvokeCompletion(
+					completion=response_text,
+					usage=usage,
+					stop_reason=response.stop_reason,
+				)
+
+			else:
+				# Use tool calling for structured output
+				# Create a tool that represents the output format
+				tool_name = output_format.__name__
+				schema = SchemaOptimizer.create_optimized_json_schema(output_format)
+
+				# Remove title from schema if present (Anthropic doesn't like it in parameters)
+				if 'title' in schema:
+					del schema['title']
+
+				tool = ToolParam(
+					name=tool_name,
+					description=f'Extract information in the format of {tool_name}',
+					input_schema=schema,
+					cache_control=CacheControlEphemeralParam(type='ephemeral'),
+				)
+
+				# Force the model to use this tool
+				tool_choice = ToolChoiceToolParam(type='tool', name=tool_name)
+
+				response = await self.get_client().messages.create(
+					model=self.model,
+					messages=anthropic_messages,
+					tools=[tool],
+					system=system_prompt or omit,
+					tool_choice=tool_choice,
+					**self._get_client_params_for_invoke(),
+				)
+
+				# Ensure we have a valid Message object before accessing attributes
+				if not isinstance(response, Message):
+					raise ModelProviderError(
+						message=f'Unexpected response type from Anthropic API: {type(response).__name__}. Response: {str(response)[:200]}',
+						status_code=502,
+						model=self.name,
+					)
+
+				usage = self._get_usage(response)
+
+				# Extract the tool use block
+				for content_block in response.content:
+					if hasattr(content_block, 'type') and content_block.type == 'tool_use':
+						# Parse the tool input as the structured output
+						try:
+							return ChatInvokeCompletion(
+								completion=output_format.model_validate(content_block.input),
+								usage=usage,
+								stop_reason=response.stop_reason,
+							)
+						except Exception as e:
+							# If validation fails, try to parse it as JSON first
+							if isinstance(content_block.input, str):
+								data = json.loads(content_block.input)
+								return ChatInvokeCompletion(
+									completion=output_format.model_validate(data),
+									usage=usage,
+									stop_reason=response.stop_reason,
+								)
+							raise e
+
+				# If no tool use block found, raise an error
+				raise ValueError('Expected tool use in response but none found')
+
+		except APIConnectionError as e:
+			raise ModelProviderError(message=e.message, model=self.name) from e
+		except RateLimitError as e:
+			raise ModelRateLimitError(message=e.message, model=self.name) from e
+		except APIStatusError as e:
+			raise ModelProviderError(message=e.message, status_code=e.status_code, model=self.name) from e
+		except Exception as e:
+			raise ModelProviderError(message=str(e), model=self.name) from e