Open-source Python library for AI browser agents, plus Browser Use Cloud: stealth browsers and a hosted agent API.
Python ai-agentsai-toolsbrowser-agentbrowser-automationbrowser-usecdpcloud-browsercomputer-useheadless-browserllmmcpplaywrightpythonremote-browserstealth-browserweb-automationweb-scraping
Add Mistral provider with schema optimizer and presets
MagellaX5de9b9956737
diff --git a/browser_use/__init__.py b/browser_use/__init__.pyindex e67fe8f4e..a219ddc51 100644--- a/browser_use/__init__.py+++ b/browser_use/__init__.py@@ -56,6 +56,7 @@ if TYPE_CHECKING:from browser_use.llm.azure.chat import ChatAzureOpenAIfrom browser_use.llm.google.chat import ChatGooglefrom browser_use.llm.groq.chat import ChatGroq+ from browser_use.llm.mistral.chat import ChatMistralfrom browser_use.llm.ollama.chat import ChatOllamafrom browser_use.llm.openai.chat import ChatOpenAIfrom browser_use.tools.service import Controller, Tools@@ -84,6 +85,7 @@ _LAZY_IMPORTS = {'ChatGoogle': ('browser_use.llm.google.chat', 'ChatGoogle'),'ChatAnthropic': ('browser_use.llm.anthropic.chat', 'ChatAnthropic'),'ChatGroq': ('browser_use.llm.groq.chat', 'ChatGroq'),+ 'ChatMistral': ('browser_use.llm.mistral.chat', 'ChatMistral'),'ChatAzureOpenAI': ('browser_use.llm.azure.chat', 'ChatAzureOpenAI'),'ChatOllama': ('browser_use.llm.ollama.chat', 'ChatOllama'),# LLM models module@@ -129,6 +131,7 @@ __all__ = ['ChatGoogle','ChatAnthropic','ChatGroq',+ 'ChatMistral','ChatAzureOpenAI','ChatOllama','Tools',diff --git a/browser_use/llm/README.md b/browser_use/llm/README.mdindex fedce4fe6..39feb7421 100644--- a/browser_use/llm/README.md+++ b/browser_use/llm/README.md@@ -8,6 +8,11 @@ We officially support the following LLMs:- Groq- Ollama- DeepSeek+- Mistral++## Mistral specifics++Use `ChatMistral` with `MISTRAL_API_KEY` (and optional `MISTRAL_BASE_URL`). Structured outputs automatically strip unsupported JSON schema keywords (`minLength`, `maxLength`, `pattern`, `format`), and generation uses `max_tokens` plus the optional `safe_prompt` flag.## Migrating from LangChaindiff --git a/browser_use/llm/__init__.py b/browser_use/llm/__init__.pyindex badaef2eb..38d0d498d 100644--- a/browser_use/llm/__init__.py+++ b/browser_use/llm/__init__.py@@ -33,6 +33,7 @@ if TYPE_CHECKING:from browser_use.llm.deepseek.chat import ChatDeepSeekfrom browser_use.llm.google.chat import ChatGooglefrom browser_use.llm.groq.chat import ChatGroq+ from browser_use.llm.mistral.chat import ChatMistralfrom browser_use.llm.ollama.chat import ChatOllamafrom browser_use.llm.openai.chat import ChatOpenAIfrom browser_use.llm.openrouter.chat import ChatOpenRouter@@ -81,6 +82,7 @@ _LAZY_IMPORTS = {'ChatDeepSeek': ('browser_use.llm.deepseek.chat', 'ChatDeepSeek'),'ChatGoogle': ('browser_use.llm.google.chat', 'ChatGoogle'),'ChatGroq': ('browser_use.llm.groq.chat', 'ChatGroq'),+ 'ChatMistral': ('browser_use.llm.mistral.chat', 'ChatMistral'),'ChatOllama': ('browser_use.llm.ollama.chat', 'ChatOllama'),'ChatOpenAI': ('browser_use.llm.openai.chat', 'ChatOpenAI'),'ChatOpenRouter': ('browser_use.llm.openrouter.chat', 'ChatOpenRouter'),@@ -140,6 +142,7 @@ __all__ = ['ChatAnthropicBedrock','ChatAWSBedrock','ChatGroq',+ 'ChatMistral','ChatAzureOpenAI','ChatOllama','ChatOpenRouter',diff --git a/browser_use/llm/mistral/__init__.py b/browser_use/llm/mistral/__init__.pynew file mode 100644index 000000000..c02dcbb9f--- /dev/null+++ b/browser_use/llm/mistral/__init__.py@@ -0,0 +1,5 @@+"""Mistral chat model integration."""++from browser_use.llm.mistral.chat import ChatMistral++__all__ = ['ChatMistral']diff --git a/browser_use/llm/mistral/chat.py b/browser_use/llm/mistral/chat.pynew file mode 100644index 000000000..751659495--- /dev/null+++ b/browser_use/llm/mistral/chat.py@@ -0,0 +1,209 @@+from __future__ import annotations++import json+import logging+import os+from dataclasses import dataclass+from typing import Any, Mapping, TypeVar, overload++import httpx+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.mistral.schema import MistralSchemaOptimizer+from browser_use.llm.openai.serializer import OpenAIMessageSerializer+from browser_use.llm.views import ChatInvokeCompletion, ChatInvokeUsage++logger = logging.getLogger(__name__)+T = TypeVar('T', bound=BaseModel)+++@dataclass+class ChatMistral(BaseChatModel):+ """Mistral /chat/completions wrapper with schema sanitization."""++ model: str = 'mistral-medium-latest'++ # Generation params+ temperature: float | None = 0.2+ top_p: float | None = None+ max_tokens: int | None = 4096 # Mistral expects max_tokens (not max_completion_tokens)+ seed: int | None = None+ safe_prompt: bool = False++ # Client params+ api_key: str | None = None # Falls back to MISTRAL_API_KEY+ base_url: str | httpx.URL = 'https://api.mistral.ai/v1'+ timeout: float | httpx.Timeout | None = None+ max_retries: int = 5+ default_headers: Mapping[str, str] | None = None+ default_query: Mapping[str, object] | None = None+ http_client: httpx.AsyncClient | None = None++ @property+ def provider(self) -> str:+ return 'mistral'++ @property+ def name(self) -> str:+ return str(self.model)++ def _get_api_key(self) -> str:+ key = self.api_key or os.getenv('MISTRAL_API_KEY')+ if not key:+ raise ModelProviderError('Missing Mistral API key', status_code=401, model=self.name)+ return key++ def _get_base_url(self) -> str:+ return str(os.getenv('MISTRAL_BASE_URL', self.base_url)).rstrip('/')++ def _auth_headers(self) -> dict[str, str]:+ headers = {+ 'Authorization': f'Bearer {self._get_api_key()}',+ 'Content-Type': 'application/json',+ }+ if self.default_headers:+ headers.update(self.default_headers)+ return headers++ def _client(self) -> httpx.AsyncClient:+ if self.http_client:+ return self.http_client++ if not hasattr(self, '_cached_client'):+ transport = httpx.AsyncHTTPTransport(retries=self.max_retries)+ self._cached_client = httpx.AsyncClient(timeout=self.timeout, transport=transport)+ return self._cached_client++ def _serialize_messages(self, messages: list[BaseMessage]) -> list[dict[str, Any]]:+ raw_messages: list[dict[str, Any]] = []+ for msg in OpenAIMessageSerializer.serialize_messages(messages):+ if hasattr(msg, 'model_dump'):+ raw_messages.append(msg.model_dump(exclude_none=True))+ else:+ raw_messages.append(msg) # type: ignore[arg-type]+ return raw_messages++ def _build_usage(self, usage: dict[str, Any] | None) -> ChatInvokeUsage | None:+ if not usage:+ return None++ return ChatInvokeUsage(+ prompt_tokens=usage.get('prompt_tokens', 0),+ prompt_cached_tokens=None,+ prompt_cache_creation_tokens=None,+ prompt_image_tokens=None,+ completion_tokens=usage.get('completion_tokens', 0),+ total_tokens=usage.get('total_tokens', 0),+ )++ def _extract_content_text(self, choice: dict[str, Any]) -> str:+ message = choice.get('message', {})+ content = message.get('content')++ if isinstance(content, list):+ text_parts = []+ for part in content:+ if isinstance(part, dict):+ if part.get('type') == 'text' and 'text' in part:+ text_parts.append(part.get('text', ''))+ elif 'content' in part:+ text_parts.append(str(part['content']))+ return ''.join(text_parts)++ if isinstance(content, dict):+ return json.dumps(content)++ return content or ''++ def _parse_error(self, response: httpx.Response) -> str:+ try:+ body = response.json()+ if isinstance(body, dict):+ for key in ('message', 'error', 'detail'):+ val = body.get(key)+ if isinstance(val, dict):+ val = val.get('message') or val.get('detail')+ if val:+ return str(val)+ except Exception:+ pass+ return response.text++ async def _post(self, payload: dict[str, Any]) -> dict[str, Any]:+ url = f"{self._get_base_url()}/chat/completions"+ client = self._client()+ response = await client.post(url, headers=self._auth_headers(), json=payload, params=self.default_query)++ if response.status_code >= 400:+ message = self._parse_error(response)+ if response.status_code == 429:+ raise ModelRateLimitError(message=message, status_code=response.status_code, model=self.name)+ raise ModelProviderError(message=message, status_code=response.status_code, model=self.name)++ try:+ return response.json()+ except Exception as e:+ raise ModelProviderError(message=f'Failed to parse Mistral response: {e}', model=self.name) from e++ @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]:+ payload: dict[str, Any] = {+ 'model': self.model,+ 'messages': self._serialize_messages(messages),+ }++ # Generation params+ if self.temperature is not None:+ payload['temperature'] = self.temperature+ if self.top_p is not None:+ payload['top_p'] = self.top_p+ if self.max_tokens is not None:+ payload['max_tokens'] = self.max_tokens+ if self.seed is not None:+ payload['seed'] = self.seed+ if self.safe_prompt:+ payload['safe_prompt'] = self.safe_prompt++ # Structured output path+ if output_format is not None:+ payload['response_format'] = {+ 'type': 'json_schema',+ 'json_schema': {+ 'name': 'agent_output',+ 'strict': True,+ 'schema': MistralSchemaOptimizer.create_mistral_compatible_schema(output_format),+ },+ }++ try:+ data = await self._post(payload)+ choices = data.get('choices', [])+ if not choices:+ raise ModelProviderError('Mistral returned no choices', model=self.name)++ content_text = self._extract_content_text(choices[0])+ usage = self._build_usage(data.get('usage'))++ if output_format is None:+ return ChatInvokeCompletion(completion=content_text, usage=usage)++ parsed = output_format.model_validate_json(content_text)+ return ChatInvokeCompletion(completion=parsed, usage=usage)++ except ModelProviderError:+ raise+ except ModelRateLimitError:+ raise+ except Exception as e:+ logger.error(f'Mistral invocation failed: {e}')+ raise ModelProviderError(message=str(e), model=self.name) from ediff --git a/browser_use/llm/mistral/schema.py b/browser_use/llm/mistral/schema.pynew file mode 100644index 000000000..e65971c8a--- /dev/null+++ b/browser_use/llm/mistral/schema.py@@ -0,0 +1,36 @@+"""Schema optimizer for Mistral-compatible JSON schemas."""++from __future__ import annotations++from typing import Any++from pydantic import BaseModel++from browser_use.llm.schema import SchemaOptimizer+++class MistralSchemaOptimizer:+ """Create JSON schemas that avoid Mistral's unsupported keywords."""++ UNSUPPORTED_KEYWORDS = {'minLength', 'maxLength', 'pattern', 'format'}++ @classmethod+ def create_mistral_compatible_schema(cls, model: type[BaseModel]) -> dict[str, Any]:+ """+ Build a Mistral-safe schema by starting with the standard optimized schema and+ then stripping unsupported validation keywords recursively.+ """+ base_schema = SchemaOptimizer.create_optimized_json_schema(model)+ return cls._strip_unsupported_keywords(base_schema)++ @classmethod+ def _strip_unsupported_keywords(cls, obj: Any) -> Any:+ if isinstance(obj, dict):+ return {+ key: cls._strip_unsupported_keywords(value)+ for key, value in obj.items()+ if key not in cls.UNSUPPORTED_KEYWORDS+ }+ if isinstance(obj, list):+ return [cls._strip_unsupported_keywords(item) for item in obj]+ return objdiff --git a/browser_use/llm/models.py b/browser_use/llm/models.pyindex d09cd4c36..2363d9e32 100644--- a/browser_use/llm/models.py+++ b/browser_use/llm/models.py@@ -15,6 +15,7 @@ from typing import TYPE_CHECKINGfrom browser_use.llm.azure.chat import ChatAzureOpenAIfrom browser_use.llm.google.chat import ChatGoogle+from browser_use.llm.mistral.chat import ChatMistralfrom browser_use.llm.openai.chat import ChatOpenAIif TYPE_CHECKING:@@ -52,6 +53,11 @@ google_gemini_2_0_pro: 'BaseChatModel'google_gemini_2_5_pro: 'BaseChatModel'google_gemini_2_5_flash: 'BaseChatModel'google_gemini_2_5_flash_lite: 'BaseChatModel'+mistral_large: 'BaseChatModel'+mistral_medium: 'BaseChatModel'+mistral_small: 'BaseChatModel'+codestral: 'BaseChatModel'+pixtral_large: 'BaseChatModel'def get_llm_by_name(model_name: str):@@ -70,6 +76,19 @@ def get_llm_by_name(model_name: str):if not model_name:raise ValueError('Model name cannot be empty')+ # Handle top-level Mistral aliases without provider prefix+ mistral_aliases = {+ 'mistral_large': 'mistral-large-latest',+ 'mistral_medium': 'mistral-medium-latest',+ 'mistral_small': 'mistral-small-latest',+ 'codestral': 'codestral-latest',+ 'pixtral_large': 'pixtral-large-latest',+ }+ if model_name in mistral_aliases:+ api_key = os.getenv('MISTRAL_API_KEY')+ base_url = os.getenv('MISTRAL_BASE_URL', 'https://api.mistral.ai/v1')+ return ChatMistral(model=mistral_aliases[model_name], api_key=api_key, base_url=base_url)+# Parse model nameparts = model_name.split('_', 1)if len(parts) < 2:@@ -108,8 +127,22 @@ def get_llm_by_name(model_name: str):api_key = os.getenv('GOOGLE_API_KEY')return ChatGoogle(model=model, api_key=api_key)+ # Mistral Models+ elif provider == 'mistral':+ api_key = os.getenv('MISTRAL_API_KEY')+ base_url = os.getenv('MISTRAL_BASE_URL', 'https://api.mistral.ai/v1')+ mistral_map = {+ 'large': 'mistral-large-latest',+ 'medium': 'mistral-medium-latest',+ 'small': 'mistral-small-latest',+ 'codestral': 'codestral-latest',+ 'pixtral-large': 'pixtral-large-latest',+ }+ resolved_model = mistral_map.get(model_part, model.replace('_', '-'))+ return ChatMistral(model=resolved_model, api_key=api_key, base_url=base_url)+else:- available_providers = ['openai', 'azure', 'google']+ available_providers = ['openai', 'azure', 'google', 'mistral']raise ValueError(f"Unknown provider: '{provider}'. Available providers: {', '.join(available_providers)}")@@ -123,6 +156,8 @@ def __getattr__(name: str) -> 'BaseChatModel':return ChatAzureOpenAI # type: ignoreelif name == 'ChatGoogle':return ChatGoogle # type: ignore+ elif name == 'ChatMistral':+ return ChatMistral # type: ignore# Handle model instances - these are the main use casetry:@@ -135,6 +170,7 @@ __all__ = ['ChatOpenAI','ChatAzureOpenAI','ChatGoogle',+ 'ChatMistral','get_llm_by_name',# OpenAI instances - created on demand'openai_gpt_4o',@@ -168,4 +204,10 @@ __all__ = ['google_gemini_2_5_pro','google_gemini_2_5_flash','google_gemini_2_5_flash_lite',+ # Mistral instances - created on demand+ 'mistral_large',+ 'mistral_medium',+ 'mistral_small',+ 'codestral',+ 'pixtral_large',]diff --git a/browser_use/llm/tests/test_mistral_schema.py b/browser_use/llm/tests/test_mistral_schema.pynew file mode 100644index 000000000..463c0cfcd--- /dev/null+++ b/browser_use/llm/tests/test_mistral_schema.py@@ -0,0 +1,28 @@+from pydantic import BaseModel, Field++from browser_use.llm.mistral.schema import MistralSchemaOptimizer+++class NestedExample(BaseModel):+ code: str = Field(..., min_length=2, max_length=4, pattern='[A-Z]+')+ description: str+++class RootExample(BaseModel):+ item: NestedExample+ email: str = Field(..., format='email')+++def test_mistral_schema_strips_unsupported_keywords():+ schema = MistralSchemaOptimizer.create_mistral_compatible_schema(RootExample)++ def _assert_no_banned_keys(obj):+ if isinstance(obj, dict):+ for key, value in obj.items():+ assert key not in {'minLength', 'maxLength', 'pattern', 'format'}+ _assert_no_banned_keys(value)+ elif isinstance(obj, list):+ for item in obj:+ _assert_no_banned_keys(item)++ _assert_no_banned_keys(schema)diff --git a/examples/models/mistral.py b/examples/models/mistral.pynew file mode 100644index 000000000..5397e737e--- /dev/null+++ b/examples/models/mistral.py@@ -0,0 +1,28 @@+"""+Simple agent run with Mistral.++You need to set MISTRAL_API_KEY in your environment (and optionally MISTRAL_BASE_URL).+"""++import asyncio++from dotenv import load_dotenv++from browser_use import Agent+from browser_use.llm.mistral import ChatMistral++load_dotenv()++llm = ChatMistral(model='mistral-medium-latest', temperature=0)+agent = Agent(+ llm=llm,+ task='List two fun weekend activities in Barcelona.',+)+++async def main():+ await agent.run(max_steps=10)+ input('Press Enter to continue...')+++asyncio.run(main())