aip-agents-binary 0.5.20__py3-none-manylinux_2_31_x86_64.whl

aip_agents/tools/browser_use/browser_use_tool.pyi

@@ -0,0 +1,50 @@
+from _typeshed import Incomplete
+from aip_agents.tools.browser_use import session_errors as session_errors
+from aip_agents.tools.browser_use.action_parser import ActionParser as ActionParser
+from aip_agents.tools.browser_use.llm_config import build_browser_use_llm as build_browser_use_llm, configure_browser_use_environment as configure_browser_use_environment
+from aip_agents.tools.browser_use.schemas import BrowserUseToolConfig as BrowserUseToolConfig, BrowserUseToolInput as BrowserUseToolInput
+from aip_agents.tools.browser_use.session import BrowserSession as BrowserSession
+from aip_agents.tools.browser_use.steel_session_recording import SteelSessionRecorder as SteelSessionRecorder
+from aip_agents.tools.browser_use.streaming import create_error_response as create_error_response, create_step_response as create_step_response, generate_step_content as generate_step_content, generate_thinking_message as generate_thinking_message, yield_iframe_activity as yield_iframe_activity, yield_status_message as yield_status_message, yield_thinking_marker as yield_thinking_marker
+from aip_agents.tools.browser_use.structured_data_parser import detect_structured_data_failure as detect_structured_data_failure
+from aip_agents.tools.browser_use.types import BrowserUseFatalError as BrowserUseFatalError, RetryDecision as RetryDecision, StreamingResponse as StreamingResponse, StreamingState as StreamingState, ToolCallInfo as ToolCallInfo
+from aip_agents.utils.logger import get_logger as get_logger
+from langchain_core.runnables import RunnableConfig
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel as BaseModel
+
+logger: Incomplete
+
+class BrowserUseTool(BaseTool):
+    """Tool to execute web automation tasks using browser-use framework.
+
+    This tool provides step-by-step execution of browser automation tasks with detailed
+    logging of intermediate steps, including the agent's thinking process, goals, and
+    results at each step.
+    """
+    name: str
+    description: str
+    args_schema: type[BaseModel]
+    tool_config_schema: type[BaseModel]
+    MAX_SESSION_RELEASE_RETRIES: int
+    SESSION_RELEASE_SLEEP_TIME_IN_S: int
+    async def arun_streaming(self, task: str = None, config: RunnableConfig | None = None, **kwargs):
+        """Execute a web automation task using browser-use asynchronously with streaming output.
+
+        This method creates a Steel browser session, initializes a browser-use agent with
+        the specified task, and executes the automation step by step, yielding results
+        in streaming fashion. Starts background recording after completion.
+
+        Args:
+            task (str, optional): The task prompt for the AI agent to execute in the browser.
+                                 If not provided, will attempt to extract from kwargs.
+            config (RunnableConfig): RunnableConfig containing tool configuration.
+            **kwargs: Additional parameters that may contain the task or other tool-specific arguments.
+
+        Yields:
+            dict: Step-by-step results in standardized StreamingResponse format.
+
+        Raises:
+            Exception: Any exception that occurs during task execution will be caught
+                and yielded as an error message.
+        """

aip_agents/tools/browser_use/llm_config.py

@@ -0,0 +1,120 @@
+"""Helpers for configuring browser-use LLM instances and environment flags.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from browser_use.llm import ChatOpenAI
+from browser_use.logging_config import setup_logging
+
+
+def model_disallows_tunable_params(model: Any) -> bool:
+    """Return True if the provider forbids temperature/frequency overrides for the model.
+
+    Args:
+        model: The model name or identifier to check.
+
+    Returns:
+        bool: True if the model disallows tunable parameters, False otherwise.
+    """
+    model_name = str(model).lower()
+
+    if model_name.startswith("gpt-5"):
+        return True
+
+    short_name = model_name.split("-", 1)[0]
+    return short_name.startswith("o") and short_name[1:].isdigit()
+
+
+def supports_temperature_override(model: Any) -> bool:
+    """Return True when the given model supports setting a custom temperature.
+
+    Args:
+        model: The model name or identifier to check.
+
+    Returns:
+        bool: True if the model supports temperature override, False otherwise.
+    """
+    return not model_disallows_tunable_params(model)
+
+
+def supports_frequency_penalty(model: Any) -> bool:
+    """Return True when the given model supports custom frequency penalties.
+
+    Args:
+        model: The model name or identifier to check.
+
+    Returns:
+        bool: True if the model supports frequency penalty override, False otherwise.
+    """
+    return not model_disallows_tunable_params(model)
+
+
+def build_browser_use_llm(
+    *,
+    model: Any,
+    reasoning_effort: Any,
+    temperature: float | None,
+    api_key: str,
+    base_url: str | None = None,
+) -> ChatOpenAI:
+    """Construct a ChatOpenAI instance with browser-use specific safeguards.
+
+    Args:
+        model: The model name or identifier to use.
+        reasoning_effort: The reasoning effort level for the model.
+        temperature: Optional temperature setting for the model. Can be None.
+        api_key: The API key for authentication.
+        base_url: The base URL for the model.
+
+    Returns:
+        ChatOpenAI: The configured ChatOpenAI instance.
+    """
+    llm_kwargs: dict[str, Any] = {
+        "model": model,
+        "reasoning_effort": reasoning_effort,
+        "api_key": api_key,
+        "base_url": base_url,
+    }
+
+    if temperature is not None and supports_temperature_override(model):
+        llm_kwargs["temperature"] = temperature
+    else:
+        llm_kwargs["temperature"] = None
+
+    if not supports_frequency_penalty(model):
+        llm_kwargs["frequency_penalty"] = None
+
+    return ChatOpenAI(**llm_kwargs)
+
+
+def configure_browser_use_environment(enable_cloud_sync: bool, logging_level: str) -> None:
+    """Ensure Browser Use environment flags are aligned with tool configuration.
+
+    Args:
+        enable_cloud_sync: Whether to enable cloud synchronization for browser sessions.
+        logging_level: The desired logging level for browser use operations.
+    """
+    desired_sync = "true" if enable_cloud_sync else "false"
+    if os.environ.get("BROWSER_USE_CLOUD_SYNC") != desired_sync:
+        os.environ["BROWSER_USE_CLOUD_SYNC"] = desired_sync
+
+    desired_level = logging_level.lower()
+    current_level = os.environ.get("BROWSER_USE_LOGGING_LEVEL")
+    if not current_level or current_level.lower() != desired_level:
+        os.environ["BROWSER_USE_LOGGING_LEVEL"] = desired_level
+        setup_logging(log_level=desired_level, force_setup=True)
+
+
+__all__ = [
+    "build_browser_use_llm",
+    "configure_browser_use_environment",
+    "model_disallows_tunable_params",
+    "supports_frequency_penalty",
+    "supports_temperature_override",
+]

aip_agents/tools/browser_use/llm_config.pyi

@@ -0,0 +1,52 @@
+from browser_use.llm import ChatOpenAI
+from typing import Any
+
+__all__ = ['build_browser_use_llm', 'configure_browser_use_environment', 'model_disallows_tunable_params', 'supports_frequency_penalty', 'supports_temperature_override']
+
+def model_disallows_tunable_params(model: Any) -> bool:
+    """Return True if the provider forbids temperature/frequency overrides for the model.
+
+    Args:
+        model: The model name or identifier to check.
+
+    Returns:
+        bool: True if the model disallows tunable parameters, False otherwise.
+    """
+def supports_temperature_override(model: Any) -> bool:
+    """Return True when the given model supports setting a custom temperature.
+
+    Args:
+        model: The model name or identifier to check.
+
+    Returns:
+        bool: True if the model supports temperature override, False otherwise.
+    """
+def supports_frequency_penalty(model: Any) -> bool:
+    """Return True when the given model supports custom frequency penalties.
+
+    Args:
+        model: The model name or identifier to check.
+
+    Returns:
+        bool: True if the model supports frequency penalty override, False otherwise.
+    """
+def build_browser_use_llm(*, model: Any, reasoning_effort: Any, temperature: float | None, api_key: str, base_url: str | None = None) -> ChatOpenAI:
+    """Construct a ChatOpenAI instance with browser-use specific safeguards.
+
+    Args:
+        model: The model name or identifier to use.
+        reasoning_effort: The reasoning effort level for the model.
+        temperature: Optional temperature setting for the model. Can be None.
+        api_key: The API key for authentication.
+        base_url: The base URL for the model.
+
+    Returns:
+        ChatOpenAI: The configured ChatOpenAI instance.
+    """
+def configure_browser_use_environment(enable_cloud_sync: bool, logging_level: str) -> None:
+    """Ensure Browser Use environment flags are aligned with tool configuration.
+
+    Args:
+        enable_cloud_sync: Whether to enable cloud synchronization for browser sessions.
+        logging_level: The desired logging level for browser use operations.
+    """

aip_agents/tools/browser_use/minio_storage.py

@@ -0,0 +1,198 @@
+"""MinIO Storage Handler for Steel Session Recording.
+
+This module provides MinIO cloud storage functionality for uploading and managing
+video files from Steel session recordings. It handles file uploads, bucket management,
+and presigned URL generation for secure file access.
+
+The module supports:
+- Automatic bucket creation and validation
+- Secure file uploads with proper content types
+- Presigned URL generation for temporary file access
+- Directory prefix support for organized storage
+- Comprehensive error handling and logging
+
+Authors:
+    Reinhart Linanda (reinhart.linanda@gdplabs.id)
+"""
+
+import os
+
+from dotenv import load_dotenv
+from minio import Minio
+from minio.error import S3Error
+
+load_dotenv()
+
+OBJECT_NAME_PREFIX = "steel-recordings/"
+
+
+class MinIOStorage:
+    """Handles MinIO cloud storage operations for video files.
+
+    This class provides a complete interface for MinIO operations including:
+    - Connection management with authentication
+    - Bucket existence validation and creation
+    - File upload with proper metadata
+    - Presigned URL generation for secure access
+
+    Attributes:
+        endpoint: MinIO server endpoint URL.
+        access_key: MinIO access key for authentication.
+        secret_key: MinIO secret key for authentication.
+        secure: Whether to use HTTPS/TLS for connections.
+        bucket_name: Target bucket for file storage.
+        directory_prefix: Optional directory prefix for organized storage.
+        client: MinIO client instance for API operations.
+    """
+
+    def __init__(self):
+        """Initialize MinIO storage with configuration from environment variables.
+
+        Reads configuration from the following environment variables:
+        - OBJECT_STORAGE_URL: MinIO server endpoint
+        - OBJECT_STORAGE_USER: MinIO access key
+        - OBJECT_STORAGE_PASSWORD: MinIO secret key
+        - OBJECT_STORAGE_SECURE: Whether to use HTTPS (default: False)
+        - OBJECT_STORAGE_BUCKET: Target bucket name
+        - OBJECT_STORAGE_DIRECTORY_PREFIX: Optional directory prefix
+
+        Raises:
+            ValueError: If required environment variables are missing.
+            Exception: If bucket creation or validation fails.
+
+        Note:
+            The method automatically ensures the target bucket exists,
+            creating it if necessary.
+        """
+        self.endpoint = os.getenv("OBJECT_STORAGE_URL")
+        self.access_key = os.getenv("OBJECT_STORAGE_USER")
+        self.secret_key = os.getenv("OBJECT_STORAGE_PASSWORD")
+        self.secure = os.getenv("OBJECT_STORAGE_SECURE", "False").lower() == "true"
+        self.bucket_name = os.getenv("OBJECT_STORAGE_BUCKET")
+        self.directory_prefix = os.getenv("OBJECT_STORAGE_DIRECTORY_PREFIX")
+
+        if not all([self.endpoint, self.access_key, self.secret_key, self.bucket_name]):
+            raise ValueError(
+                "MinIO configuration incomplete. Set OBJECT_STORAGE_URL, OBJECT_STORAGE_USER, OBJECT_STORAGE_PASSWORD,"
+                "and OBJECT_STORAGE_BUCKET."
+            )
+
+        self.client = Minio(
+            self.endpoint,
+            access_key=self.access_key,
+            secret_key=self.secret_key,
+            secure=self.secure,
+        )
+
+        # Ensure bucket exists
+        self._ensure_bucket_exists()
+
+    def _ensure_bucket_exists(self):
+        """Ensure the configured bucket exists, create if it doesn't.
+
+        This method checks if the target bucket exists and creates it if necessary.
+        It's called during initialization to ensure the storage is ready for use.
+
+        Raises:
+            Exception: If bucket creation or validation fails.
+
+        Note:
+            Bucket creation failures are logged as warnings but don't prevent
+            the class from being usable (existing buckets can still be accessed).
+        """
+        try:
+            if not self.client.bucket_exists(self.bucket_name):
+                self.client.make_bucket(self.bucket_name)
+        except S3Error as e:
+            raise Exception(f"Warning: Could not ensure bucket exists: {e}") from e
+
+    def get_object_name(self, object_name: str) -> str:
+        """Get the object name with the directory prefix.
+
+        This method constructs the full object path by combining the directory
+        prefix with the base object name. It ensures consistent path structure
+        for all stored files.
+
+        Args:
+            object_name: Name of the object in MinIO.
+
+        Returns:
+            str: Object name with the directory prefix and steel-recordings subdirectory.
+                Format: {prefix}/steel-recordings/{object_name} or steel-recordings/{object_name}
+
+        Note:
+            The method automatically adds a "steel-recordings" subdirectory to
+            organize video files separately from other content.
+        """
+        object_name = f"{OBJECT_NAME_PREFIX}{object_name}"
+        if self.directory_prefix:
+            return f"{self.directory_prefix}/{object_name}"
+        return object_name
+
+    def upload_file(self, file_path: str, object_name: str) -> None:
+        """Upload a file to MinIO bucket.
+
+        This method handles the complete file upload process including:
+        - File existence validation
+        - Proper content type setting for video files
+        - Error handling and logging
+        - Structured object naming with prefixes
+
+        Args:
+            file_path: Local path to the file to upload.
+            object_name: Name to use for the object in MinIO.
+
+        Raises:
+            Exception: If the file doesn't exist or upload fails.
+                Specific S3Error details are included in the exception message.
+
+        Note:
+            The method automatically sets the content type to "video/webm"
+            for proper video file handling in browsers and applications.
+        """
+        try:
+            if not os.path.exists(file_path):
+                raise Exception(f"File not found: {file_path}")
+
+            # Upload the file
+            self.client.fput_object(
+                self.bucket_name,
+                self.get_object_name(object_name),
+                file_path,
+                content_type="video/webm",
+            )
+
+        except S3Error as e:
+            raise Exception(f"Error uploading to MinIO: {e}") from e
+        except Exception as e:
+            raise Exception(f"Unexpected error during upload: {e}") from e
+
+    def get_file_url(self, object_name: str) -> str:
+        """Generate a presigned URL for accessing the uploaded file.
+
+        This method creates a temporary, secure URL that allows access to the
+        uploaded file without requiring MinIO credentials. The URL is valid
+        for a limited time and provides secure, direct access to the file.
+
+        Args:
+            object_name: Name of the object in MinIO.
+
+        Returns:
+            str: Presigned URL for secure file access.
+                The URL includes authentication tokens and is valid for a limited time.
+
+        Raises:
+            Exception: If presigned URL generation fails.
+                S3Error details are included in the exception message.
+
+        Note:
+            Presigned URLs are useful for sharing files temporarily without
+            exposing MinIO credentials or requiring users to have storage access.
+        """
+        try:
+            return self.client.presigned_get_object(
+                self.bucket_name,
+                self.get_object_name(object_name),
+            )
+        except S3Error as e:
+            raise Exception(f"Error generating presigned URL: {e}") from e

aip_agents/tools/browser_use/minio_storage.pyi

@@ -0,0 +1,109 @@
+from _typeshed import Incomplete
+
+OBJECT_NAME_PREFIX: str
+
+class MinIOStorage:
+    """Handles MinIO cloud storage operations for video files.
+
+    This class provides a complete interface for MinIO operations including:
+    - Connection management with authentication
+    - Bucket existence validation and creation
+    - File upload with proper metadata
+    - Presigned URL generation for secure access
+
+    Attributes:
+        endpoint: MinIO server endpoint URL.
+        access_key: MinIO access key for authentication.
+        secret_key: MinIO secret key for authentication.
+        secure: Whether to use HTTPS/TLS for connections.
+        bucket_name: Target bucket for file storage.
+        directory_prefix: Optional directory prefix for organized storage.
+        client: MinIO client instance for API operations.
+    """
+    endpoint: Incomplete
+    access_key: Incomplete
+    secret_key: Incomplete
+    secure: Incomplete
+    bucket_name: Incomplete
+    directory_prefix: Incomplete
+    client: Incomplete
+    def __init__(self) -> None:
+        """Initialize MinIO storage with configuration from environment variables.
+
+        Reads configuration from the following environment variables:
+        - OBJECT_STORAGE_URL: MinIO server endpoint
+        - OBJECT_STORAGE_USER: MinIO access key
+        - OBJECT_STORAGE_PASSWORD: MinIO secret key
+        - OBJECT_STORAGE_SECURE: Whether to use HTTPS (default: False)
+        - OBJECT_STORAGE_BUCKET: Target bucket name
+        - OBJECT_STORAGE_DIRECTORY_PREFIX: Optional directory prefix
+
+        Raises:
+            ValueError: If required environment variables are missing.
+            Exception: If bucket creation or validation fails.
+
+        Note:
+            The method automatically ensures the target bucket exists,
+            creating it if necessary.
+        """
+    def get_object_name(self, object_name: str) -> str:
+        '''Get the object name with the directory prefix.
+
+        This method constructs the full object path by combining the directory
+        prefix with the base object name. It ensures consistent path structure
+        for all stored files.
+
+        Args:
+            object_name: Name of the object in MinIO.
+
+        Returns:
+            str: Object name with the directory prefix and steel-recordings subdirectory.
+                Format: {prefix}/steel-recordings/{object_name} or steel-recordings/{object_name}
+
+        Note:
+            The method automatically adds a "steel-recordings" subdirectory to
+            organize video files separately from other content.
+        '''
+    def upload_file(self, file_path: str, object_name: str) -> None:
+        '''Upload a file to MinIO bucket.
+
+        This method handles the complete file upload process including:
+        - File existence validation
+        - Proper content type setting for video files
+        - Error handling and logging
+        - Structured object naming with prefixes
+
+        Args:
+            file_path: Local path to the file to upload.
+            object_name: Name to use for the object in MinIO.
+
+        Raises:
+            Exception: If the file doesn\'t exist or upload fails.
+                Specific S3Error details are included in the exception message.
+
+        Note:
+            The method automatically sets the content type to "video/webm"
+            for proper video file handling in browsers and applications.
+        '''
+    def get_file_url(self, object_name: str) -> str:
+        """Generate a presigned URL for accessing the uploaded file.
+
+        This method creates a temporary, secure URL that allows access to the
+        uploaded file without requiring MinIO credentials. The URL is valid
+        for a limited time and provides secure, direct access to the file.
+
+        Args:
+            object_name: Name of the object in MinIO.
+
+        Returns:
+            str: Presigned URL for secure file access.
+                The URL includes authentication tokens and is valid for a limited time.
+
+        Raises:
+            Exception: If presigned URL generation fails.
+                S3Error details are included in the exception message.
+
+        Note:
+            Presigned URLs are useful for sharing files temporarily without
+            exposing MinIO credentials or requiring users to have storage access.
+        """

aip_agents/tools/browser_use/schemas.py

@@ -0,0 +1,119 @@
+"""Configuration schemas for Browser Use tool.
+
+Authors:
+    Reinhart Linanda (reinhart.linanda@gdplabs.id)
+"""
+
+import os
+from typing import Literal
+
+from openai.types.shared.chat_model import ChatModel
+from pydantic import BaseModel, Field
+
+
+class BrowserUseToolInput(BaseModel):
+    """Input schema for Browser Use tool."""
+
+    task: str = Field(..., description="Task prompt for the AI agent to execute in the browser")
+
+
+class BrowserUseToolConfig(BaseModel):
+    """Tool configuration schema for Browser Use tool."""
+
+    steel_api_key: str = Field(
+        default_factory=lambda: os.getenv("STEEL_API_KEY"),
+        description="Steel API key for Steel access",
+    )
+    steel_base_url: str = Field(
+        default="https://api.steel.dev",
+        description="Steel API base URL",
+    )
+    steel_ws_url: str = Field(
+        default="wss://connect.steel.dev",
+        description="Steel WebSocket URL for browser connection",
+    )
+    steel_timeout_in_ms: int = Field(
+        default=600_000,
+        description="Timeout for Steel operations in milliseconds",
+    )
+
+    browser_use_llm_openai_api_key: str = Field(
+        default_factory=lambda: os.getenv("OPENAI_API_KEY"),
+        description="OpenAI API key for browser-use access",
+    )
+    browser_use_llm_openai_model: ChatModel | str = Field(
+        default="o3",
+        description="OpenAI model to use for browser-use agent",
+    )
+    browser_use_llm_openai_temperature: float | None = Field(
+        default=None,
+        description="Temperature setting for OpenAI model (None uses provider default)",
+    )
+    browser_use_llm_openai_reasoning_effort: Literal["minimal", "low", "medium", "high"] = Field(
+        default="low",
+        description="Reasoning effort for OpenAI model",
+    )
+    browser_use_llm_openai_base_url: str | None = Field(
+        default=None,
+        description="Base URL for OpenAI model (None uses provider default)",
+    )
+
+    browser_use_page_extraction_llm_openai_api_key: str = Field(
+        default_factory=lambda: os.getenv("OPENAI_API_KEY"),
+        description="OpenAI API key for page extraction access",
+    )
+    browser_use_page_extraction_llm_openai_model: ChatModel | str = Field(
+        default="gpt-5-mini",
+        description="OpenAI model to use for page extraction",
+    )
+    browser_use_page_extraction_llm_openai_temperature: float | None = Field(
+        default=None,
+        description="Temperature setting for OpenAI model (None uses provider default)",
+    )
+    browser_use_page_extraction_llm_openai_reasoning_effort: Literal["minimal", "low", "medium", "high"] = Field(
+        default="minimal",
+        description="Reasoning effort for OpenAI model",
+    )
+    browser_use_page_extraction_llm_openai_base_url: str | None = Field(
+        default=None,
+        description="Base URL for OpenAI model (None uses provider default)",
+    )
+
+    browser_use_extend_system_message: str | None = Field(
+        default=None,
+        description="Extend system message for browser-use agent",
+    )
+
+    browser_use_vision_detail_level: Literal["auto", "low", "high"] = Field(
+        default="auto",
+        description="Detail level for vision",
+    )
+
+    browser_use_enable_cloud_sync: bool = Field(
+        default=False,
+        description="Enable Browser Use cloud sync and telemetry events",
+    )
+
+    browser_use_logging_level: Literal["debug", "info", "warning", "error", "result"] = Field(
+        default="info",
+        description="Logging verbosity for browser-use internals",
+    )
+
+    browser_use_llm_timeout_in_s: int = Field(
+        default=60,
+        description="Timeout for LLM in seconds",
+    )
+    browser_use_step_timeout_in_s: int = Field(
+        default=180,
+        description="Timeout for step in seconds",
+    )
+    browser_use_max_session_retries: int = Field(
+        default=2,
+        ge=0,
+        description="How many times to recreate the Steel session after recoverable disconnects.",
+    )
+    browser_use_session_retry_delay_in_s: float = Field(
+        default=3.0,
+        ge=0.0,
+        description="Delay (in seconds) before attempting to recover from a lost Steel session.",
+    )

aip_agents/tools/browser_use/schemas.pyi

@@ -0,0 +1,32 @@
+from openai.types.shared.chat_model import ChatModel
+from pydantic import BaseModel
+from typing import Literal
+
+class BrowserUseToolInput(BaseModel):
+    """Input schema for Browser Use tool."""
+    task: str
+
+class BrowserUseToolConfig(BaseModel):
+    """Tool configuration schema for Browser Use tool."""
+    steel_api_key: str
+    steel_base_url: str
+    steel_ws_url: str
+    steel_timeout_in_ms: int
+    browser_use_llm_openai_api_key: str
+    browser_use_llm_openai_model: ChatModel | str
+    browser_use_llm_openai_temperature: float | None
+    browser_use_llm_openai_reasoning_effort: Literal['minimal', 'low', 'medium', 'high']
+    browser_use_llm_openai_base_url: str | None
+    browser_use_page_extraction_llm_openai_api_key: str
+    browser_use_page_extraction_llm_openai_model: ChatModel | str
+    browser_use_page_extraction_llm_openai_temperature: float | None
+    browser_use_page_extraction_llm_openai_reasoning_effort: Literal['minimal', 'low', 'medium', 'high']
+    browser_use_page_extraction_llm_openai_base_url: str | None
+    browser_use_extend_system_message: str | None
+    browser_use_vision_detail_level: Literal['auto', 'low', 'high']
+    browser_use_enable_cloud_sync: bool
+    browser_use_logging_level: Literal['debug', 'info', 'warning', 'error', 'result']
+    browser_use_llm_timeout_in_s: int
+    browser_use_step_timeout_in_s: int
+    browser_use_max_session_retries: int
+    browser_use_session_retry_delay_in_s: float