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

browser_use/llm/openrouter/chat.py

@@ -0,0 +1,211 @@
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any, TypeVar, overload
+
+import httpx
+from openai import APIConnectionError, APIStatusError, AsyncOpenAI, RateLimitError
+from openai.types.chat.chat_completion import ChatCompletion
+from openai.types.shared_params.response_format_json_schema import (
+	JSONSchema,
+	ResponseFormatJSONSchema,
+)
+from pydantic import BaseModel
+
+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.openrouter.serializer import OpenRouterMessageSerializer
+from browser_use.llm.schema import SchemaOptimizer
+from browser_use.llm.views import ChatInvokeCompletion, ChatInvokeUsage
+
+T = TypeVar('T', bound=BaseModel)
+
+
+@dataclass
+class ChatOpenRouter(BaseChatModel):
+	"""
+	A wrapper around OpenRouter's chat API, which provides access to various LLM models
+	through a unified OpenAI-compatible interface.
+
+	This class implements the BaseChatModel protocol for OpenRouter's API.
+	"""
+
+	# Model configuration
+	model: str
+
+	# Model params
+	temperature: float | None = None
+	top_p: float | None = None
+	seed: int | None = None
+
+	# Client initialization parameters
+	api_key: str | None = None
+	http_referer: str | None = None  # OpenRouter specific parameter for tracking
+	base_url: str | httpx.URL = 'https://openrouter.ai/api/v1'
+	timeout: float | httpx.Timeout | None = None
+	max_retries: int = 10
+	default_headers: Mapping[str, str] | None = None
+	default_query: Mapping[str, object] | None = None
+	http_client: httpx.AsyncClient | None = None
+	_strict_response_validation: bool = False
+	extra_body: dict[str, Any] | None = None
+
+	# Static
+	@property
+	def provider(self) -> str:
+		return 'openrouter'
+
+	def _get_client_params(self) -> dict[str, Any]:
+		"""Prepare client parameters dictionary."""
+		# Define base client params
+		base_params = {
+			'api_key': self.api_key,
+			'base_url': self.base_url,
+			'timeout': self.timeout,
+			'max_retries': self.max_retries,
+			'default_headers': self.default_headers,
+			'default_query': self.default_query,
+			'_strict_response_validation': self._strict_response_validation,
+			'top_p': self.top_p,
+			'seed': self.seed,
+		}
+
+		# Create client_params dict with non-None values
+		client_params = {k: v for k, v in base_params.items() if v is not None}
+
+		# Add http_client if provided
+		if self.http_client is not None:
+			client_params['http_client'] = self.http_client
+
+		return client_params
+
+	def get_client(self) -> AsyncOpenAI:
+		"""
+		Returns an AsyncOpenAI client configured for OpenRouter.
+
+		Returns:
+		    AsyncOpenAI: An instance of the AsyncOpenAI client with OpenRouter base URL.
+		"""
+		if not hasattr(self, '_client'):
+			client_params = self._get_client_params()
+			self._client = AsyncOpenAI(**client_params)
+		return self._client
+
+	@property
+	def name(self) -> str:
+		return str(self.model)
+
+	def _get_usage(self, response: ChatCompletion) -> ChatInvokeUsage | None:
+		"""Extract usage information from the OpenRouter response."""
+		if response.usage is None:
+			return None
+
+		prompt_details = getattr(response.usage, 'prompt_tokens_details', None)
+		cached_tokens = prompt_details.cached_tokens if prompt_details else None
+
+		return ChatInvokeUsage(
+			prompt_tokens=response.usage.prompt_tokens,
+			prompt_cached_tokens=cached_tokens,
+			prompt_cache_creation_tokens=None,
+			prompt_image_tokens=None,
+			# Completion
+			completion_tokens=response.usage.completion_tokens,
+			total_tokens=response.usage.total_tokens,
+		)
+
+	@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]:
+		"""
+		Invoke the model with the given messages through OpenRouter.
+
+		Args:
+		    messages: List of chat messages
+		    output_format: Optional Pydantic model class for structured output
+
+		Returns:
+		    Either a string response or an instance of output_format
+		"""
+		openrouter_messages = OpenRouterMessageSerializer.serialize_messages(messages)
+
+		# Set up extra headers for OpenRouter
+		extra_headers = {}
+		if self.http_referer:
+			extra_headers['HTTP-Referer'] = self.http_referer
+
+		try:
+			if output_format is None:
+				# Return string response
+				response = await self.get_client().chat.completions.create(
+					model=self.model,
+					messages=openrouter_messages,
+					temperature=self.temperature,
+					top_p=self.top_p,
+					seed=self.seed,
+					extra_headers=extra_headers,
+					**(self.extra_body or {}),
+				)
+
+				usage = self._get_usage(response)
+				return ChatInvokeCompletion(
+					completion=response.choices[0].message.content or '',
+					usage=usage,
+				)
+
+			else:
+				# Create a JSON schema for structured output
+				schema = SchemaOptimizer.create_optimized_json_schema(output_format)
+
+				response_format_schema: JSONSchema = {
+					'name': 'agent_output',
+					'strict': True,
+					'schema': schema,
+				}
+
+				# Return structured response
+				response = await self.get_client().chat.completions.create(
+					model=self.model,
+					messages=openrouter_messages,
+					temperature=self.temperature,
+					top_p=self.top_p,
+					seed=self.seed,
+					response_format=ResponseFormatJSONSchema(
+						json_schema=response_format_schema,
+						type='json_schema',
+					),
+					extra_headers=extra_headers,
+					**(self.extra_body or {}),
+				)
+
+				if response.choices[0].message.content is None:
+					raise ModelProviderError(
+						message='Failed to parse structured output from model response',
+						status_code=500,
+						model=self.name,
+					)
+				usage = self._get_usage(response)
+
+				parsed = output_format.model_validate_json(response.choices[0].message.content)
+
+				return ChatInvokeCompletion(
+					completion=parsed,
+					usage=usage,
+				)
+
+		except RateLimitError as e:
+			raise ModelRateLimitError(message=e.message, model=self.name) from e
+
+		except APIConnectionError as e:
+			raise ModelProviderError(message=str(e), 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

browser_use/llm/openrouter/serializer.py

@@ -0,0 +1,26 @@
+from openai.types.chat import ChatCompletionMessageParam
+
+from browser_use.llm.messages import BaseMessage
+from browser_use.llm.openai.serializer import OpenAIMessageSerializer
+
+
+class OpenRouterMessageSerializer:
+	"""
+	Serializer for converting between custom message types and OpenRouter message formats.
+
+	OpenRouter uses the OpenAI-compatible API, so we can reuse the OpenAI serializer.
+	"""
+
+	@staticmethod
+	def serialize_messages(messages: list[BaseMessage]) -> list[ChatCompletionMessageParam]:
+		"""
+		Serialize a list of browser_use messages to OpenRouter-compatible messages.
+
+		Args:
+		    messages: List of browser_use messages
+
+		Returns:
+		    List of OpenRouter-compatible messages (identical to OpenAI format)
+		"""
+		# OpenRouter uses the same message format as OpenAI
+		return OpenAIMessageSerializer.serialize_messages(messages)

browser_use/llm/schema.py

@@ -0,0 +1,176 @@
+"""
+Utilities for creating optimized Pydantic schemas for LLM usage.
+"""
+
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class SchemaOptimizer:
+	@staticmethod
+	def create_optimized_json_schema(model: type[BaseModel]) -> dict[str, Any]:
+		"""
+		Create the most optimized schema by flattening all $ref/$defs while preserving
+		FULL descriptions and ALL action definitions. Also ensures OpenAI strict mode compatibility.
+
+		Args:
+			model: The Pydantic model to optimize
+
+		Returns:
+			Optimized schema with all $refs resolved and strict mode compatibility
+		"""
+		# Generate original schema
+		original_schema = model.model_json_schema()
+
+		# Extract $defs for reference resolution, then flatten everything
+		defs_lookup = original_schema.get('$defs', {})
+
+		def optimize_schema(
+			obj: Any,
+			defs_lookup: dict[str, Any] | None = None,
+			*,
+			in_properties: bool = False,  # NEW: track context
+		) -> Any:
+			"""Apply all optimization techniques including flattening all $ref/$defs"""
+			if isinstance(obj, dict):
+				optimized: dict[str, Any] = {}
+				flattened_ref: dict[str, Any] | None = None
+
+				# Skip unnecessary fields AND $defs (we'll inline everything)
+				skip_fields = ['additionalProperties', '$defs']
+
+				for key, value in obj.items():
+					if key in skip_fields:
+						continue
+
+					# Skip metadata "title" unless we're iterating inside an actual `properties` map
+					if key == 'title' and not in_properties:
+						continue
+
+					# Preserve FULL descriptions without truncation, skip empty ones
+					elif key == 'description':
+						if value:  # Only include non-empty descriptions
+							optimized[key] = value
+
+					# Handle type field
+					elif key == 'type':
+						optimized[key] = value
+
+					# FLATTEN: Resolve $ref by inlining the actual definition
+					elif key == '$ref' and defs_lookup:
+						ref_path = value.split('/')[-1]  # Get the definition name from "#/$defs/SomeName"
+						if ref_path in defs_lookup:
+							# Get the referenced definition and flatten it
+							referenced_def = defs_lookup[ref_path]
+							flattened_ref = optimize_schema(referenced_def, defs_lookup)
+
+					# Keep all anyOf structures (action unions) and resolve any $refs within
+					elif key == 'anyOf' and isinstance(value, list):
+						optimized[key] = [optimize_schema(item, defs_lookup) for item in value]
+
+					# Recursively optimize nested structures
+					elif key in ['properties', 'items']:
+						optimized[key] = optimize_schema(
+							value,
+							defs_lookup,
+							in_properties=(key == 'properties'),
+						)
+
+					# Keep essential validation fields
+					elif key in ['type', 'required', 'minimum', 'maximum', 'minItems', 'maxItems', 'pattern', 'default']:
+						optimized[key] = value if not isinstance(value, (dict, list)) else optimize_schema(value, defs_lookup)
+
+					# Recursively process all other fields
+					else:
+						optimized[key] = optimize_schema(value, defs_lookup) if isinstance(value, (dict, list)) else value
+
+				# If we have a flattened reference, merge it with the optimized properties
+				if flattened_ref is not None and isinstance(flattened_ref, dict):
+					# Start with the flattened reference as the base
+					result = flattened_ref.copy()
+
+					# Merge in any sibling properties that were processed
+					for key, value in optimized.items():
+						# Preserve descriptions from the original object if they exist
+						if key == 'description' and 'description' not in result:
+							result[key] = value
+						elif key != 'description':  # Don't overwrite description from flattened ref
+							result[key] = value
+
+					return result
+				else:
+					# No $ref, just return the optimized object
+					# CRITICAL: Add additionalProperties: false to ALL objects for OpenAI strict mode
+					if optimized.get('type') == 'object':
+						optimized['additionalProperties'] = False
+
+					return optimized
+
+			elif isinstance(obj, list):
+				return [optimize_schema(item, defs_lookup, in_properties=in_properties) for item in obj]
+			return obj
+
+		# Create optimized schema with flattening
+		optimized_result = optimize_schema(original_schema, defs_lookup)
+
+		# Ensure we have a dictionary (should always be the case for schema root)
+		if not isinstance(optimized_result, dict):
+			raise ValueError('Optimized schema result is not a dictionary')
+
+		optimized_schema: dict[str, Any] = optimized_result
+
+		# Additional pass to ensure ALL objects have additionalProperties: false
+		def ensure_additional_properties_false(obj: Any) -> None:
+			"""Ensure all objects have additionalProperties: false"""
+			if isinstance(obj, dict):
+				# If it's an object type, ensure additionalProperties is false
+				if obj.get('type') == 'object':
+					obj['additionalProperties'] = False
+
+				# Recursively apply to all values
+				for value in obj.values():
+					if isinstance(value, (dict, list)):
+						ensure_additional_properties_false(value)
+			elif isinstance(obj, list):
+				for item in obj:
+					if isinstance(item, (dict, list)):
+						ensure_additional_properties_false(item)
+
+		ensure_additional_properties_false(optimized_schema)
+		SchemaOptimizer._make_strict_compatible(optimized_schema)
+
+		return optimized_schema
+
+	@staticmethod
+	def _make_strict_compatible(schema: dict[str, Any] | list[Any]) -> None:
+		"""Ensure all properties are required for OpenAI strict mode"""
+		if isinstance(schema, dict):
+			# First recursively apply to nested objects
+			for key, value in schema.items():
+				if isinstance(value, (dict, list)) and key != 'required':
+					SchemaOptimizer._make_strict_compatible(value)
+
+			# Then update required for this level
+			if 'properties' in schema and 'type' in schema and schema['type'] == 'object':
+				# Add all properties to required array
+				all_props = list(schema['properties'].keys())
+				schema['required'] = all_props  # Set all properties as required
+
+		elif isinstance(schema, list):
+			for item in schema:
+				SchemaOptimizer._make_strict_compatible(item)
+
+	@staticmethod
+	def create_gemini_optimized_schema(model: type[BaseModel]) -> dict[str, Any]:
+		"""
+		Create Gemini-optimized schema, preserving explicit `required` arrays so Gemini
+		respects mandatory fields defined by the caller.
+
+		Args:
+			model: The Pydantic model to optimize
+
+		Returns:
+			Optimized schema suitable for Gemini structured output
+		"""
+		return SchemaOptimizer.create_optimized_json_schema(model)

browser_use/llm/views.py

@@ -0,0 +1,48 @@
+from typing import Generic, TypeVar, Union
+
+from pydantic import BaseModel
+
+T = TypeVar('T', bound=Union[BaseModel, str])
+
+
+class ChatInvokeUsage(BaseModel):
+	"""
+	Usage information for a chat model invocation.
+	"""
+
+	prompt_tokens: int
+	"""The number of tokens in the prompt (this includes the cached tokens as well. When calculating the cost, subtract the cached tokens from the prompt tokens)"""
+
+	prompt_cached_tokens: int | None
+	"""The number of cached tokens."""
+
+	prompt_cache_creation_tokens: int | None
+	"""Anthropic only: The number of tokens used to create the cache."""
+
+	prompt_image_tokens: int | None
+	"""Google only: The number of tokens in the image (prompt tokens is the text tokens + image tokens in that case)"""
+
+	completion_tokens: int
+	"""The number of tokens in the completion."""
+
+	total_tokens: int
+	"""The total number of tokens in the response."""
+
+
+class ChatInvokeCompletion(BaseModel, Generic[T]):
+	"""
+	Response from a chat model invocation.
+	"""
+
+	completion: T
+	"""The completion of the response."""
+
+	# Thinking stuff
+	thinking: str | None = None
+	redacted_thinking: str | None = None
+
+	usage: ChatInvokeUsage | None
+	"""The usage of the response."""
+
+	stop_reason: str | None = None
+	"""The reason the model stopped generating. Common values: 'end_turn', 'max_tokens', 'stop_sequence'."""