camel-ai 0.2.67__py3-none-any.whl → 0.2.80a2__py3-none-any.whl

camel/toolkits/google_calendar_toolkit.py

@@ -45,8 +45,21 @@ class GoogleCalendarToolkit(BaseToolkit):
             timeout (Optional[float]): The timeout value for API requests
                 in seconds. If None, no timeout is applied.
                 (default: :obj:`None`)
+
+        Note:
+            Before using this toolkit, make sure to:
+            1. Set the required environment variables: GOOGLE_CLIENT_ID and
+               GOOGLE_CLIENT_SECRET
+            2. Configure the redirect URI in Google Cloud Console to
+               http://localhost/
         """
         super().__init__(timeout=timeout)
+        logger.info(
+            "Initializing GoogleCalendarToolkit. Make sure to set "
+            "GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET environment variables, "
+            "and configure the redirect URI in Google Cloud Console to "
+            "http://localhost/"
+        )
         self.service = self._get_calendar_service()
 
     def create_event(
@@ -197,15 +210,36 @@ class GoogleCalendarToolkit(BaseToolkit):
 
             result = []
             for event in events:
-                start = event['start'].get(
-                    'dateTime', event['start'].get('date')
+                start_info = event.get('start', {})
+                end_info = event.get('end', {})
+                start_time = start_info.get(
+                    'dateTime', start_info.get('date', 'Unknown')
+                )
+                end_time = end_info.get(
+                    'dateTime', end_info.get('date', 'Unknown')
+                )
+                timezone = (
+                    start_info.get('timeZone')
+                    or end_info.get('timeZone')
+                    or event.get('timeZone')
                 )
+                attendees = [
+                    attendee.get('email')
+                    for attendee in event.get('attendees', [])
+                    if attendee.get('email')
+                ]
+                organizer = event.get('organizer', {}).get('email')
+
                 result.append(
                     {
-                        'Event ID': event['id'],
+                        'Event ID': event.get('id'),
                         'Summary': event.get('summary', 'No Title'),
-                        'Start Time': start,
+                        'Start Time': start_time,
+                        'End Time': end_time,
+                        'Timezone': timezone,
                         'Link': event.get('htmlLink'),
+                        'Attendees': attendees,
+                        'Organizer': organizer,
                     }
                 )
 

camel/toolkits/google_drive_mcp_toolkit.py

@@ -0,0 +1,54 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+from typing import Optional
+
+from .mcp_toolkit import MCPToolkit
+
+
+class GoogleDriveMCPToolkit(MCPToolkit):
+    r"""GoogleDriveMCPToolkit provides an interface for interacting with
+    Google Drive using the Google Drive MCP server.
+
+    Attributes:
+        timeout (Optional[float]): Connection timeout in seconds.
+            (default: :obj:`None`)
+    """
+
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+        credentials_path: Optional[str] = None,
+    ) -> None:
+        r"""Initializes the GoogleDriveMCPToolkit.
+
+        Args:
+            timeout (Optional[float]): Connection timeout in seconds.
+                (default: :obj:`None`)
+            credentials_path (Optional[str]): Path to the Google Drive
+                credentials file. (default: :obj:`None`)
+        """
+
+        config_dict = {
+            "mcpServers": {
+                "gdrive": {
+                    "command": "npx",
+                    "args": ["-y", "@modelcontextprotocol/server-gdrive"],
+                    "env": {"GDRIVE_CREDENTIALS_PATH": credentials_path},
+                }
+            }
+        }
+
+        # Initialize parent MCPToolkit with Playwright configuration
+        super().__init__(config_dict=config_dict, timeout=timeout)

camel/toolkits/human_toolkit.py

@@ -22,16 +22,29 @@ logger = logging.getLogger(__name__)
 
 
 class HumanToolkit(BaseToolkit):
-    r"""A class representing a toolkit for human interaction."""
+    r"""A class representing a toolkit for human interaction.
+
+    Note:
+        This toolkit should be called to send a tidy message to the user to
+        keep them informed.
+    """
 
     def ask_human_via_console(self, question: str) -> str:
-        r"""Ask a question to the human via the console.
+        r"""Use this tool to ask a question to the user when you are stuck,
+        need clarification, or require a decision to be made. This is a
+        two-way communication channel that will wait for the user's response.
+        You should use it to:
+        - Clarify ambiguous instructions or requirements.
+        - Request missing information that you cannot find (e.g., login
+        credentials, file paths).
+        - Ask for a decision when there are multiple viable options.
+        - Seek help when you encounter an error you cannot resolve on your own.
 
         Args:
-            question (str): The question to ask the human.
+            question (str): The question to ask the user.
 
         Returns:
-            str: The answer from the human.
+            str: The user's response to the question.
         """
         print(f"Question: {question}")
         logger.info(f"Question: {question}")
@@ -39,18 +52,29 @@ class HumanToolkit(BaseToolkit):
         logger.info(f"User reply: {reply}")
         return reply
 
-    def send_message_to_user(self, message: str) -> None:
-        r"""Send a message to the user, without waiting for
-        a response. This will send to stdout in a noticeable way.
+    def send_message_to_user(self, message: str) -> str:
+        r"""Use this tool to send a tidy message to the user in one short
+        sentence.
 
-        This is guaranteed to reach the user regardless of
-        actual user interface.
+        This one-way tool keeps the user informed about your progress,
+        decisions, or actions. It does not require a response.
+        You should use it to:
+        - Announce what you are about to do (e.g., "I will now search for
+          papers on GUI Agents.").
+        - Report the result of an action (e.g., "I have found 15 relevant
+          papers.").
+        - State a decision (e.g., "I will now analyze the top 10 papers.").
+        - Give a status update during a long-running task.
 
         Args:
-            message (str): The message to send to the user.
+            message (str): The tidy and informative message for the user.
+
+        Returns:
+            str: Confirmation that the message was successfully sent.
         """
         print(f"\nAgent Message:\n{message}")
         logger.info(f"\nAgent Message:\n{message}")
+        return f"Message successfully sent to user: '{message}'"
 
     def get_tools(self) -> List[FunctionTool]:
         r"""Returns a list of FunctionTool objects representing the

camel/toolkits/hybrid_browser_toolkit/__init__.py

@@ -0,0 +1,18 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from .hybrid_browser_toolkit import HybridBrowserToolkit
+
+__all__ = [
+    "HybridBrowserToolkit",
+]

camel/toolkits/hybrid_browser_toolkit/config_loader.py

@@ -0,0 +1,185 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class BrowserConfig:
+    """Browser configuration settings."""
+
+    # Browser configuration
+    headless: bool = True
+    user_data_dir: Optional[str] = None
+    stealth: bool = False
+    console_log_limit: int = 1000
+
+    # Default settings
+    default_start_url: str = "https://google.com/"
+
+    # Timeout configurations (in milliseconds)
+    default_timeout: Optional[int] = None
+    short_timeout: Optional[int] = None
+    navigation_timeout: int = 30000
+    network_idle_timeout: int = 5000
+    screenshot_timeout: int = 15000
+    page_stability_timeout: int = 1500
+    dom_content_loaded_timeout: int = 5000
+
+    # Viewport configuration
+    viewport_limit: bool = False
+
+    # CDP connection configuration
+    connect_over_cdp: bool = False
+    cdp_url: Optional[str] = None
+    cdp_keep_current_page: bool = False
+
+    # Full visual mode configuration
+    full_visual_mode: bool = False
+
+
+@dataclass
+class ToolkitConfig:
+    """Toolkit-specific configuration."""
+
+    cache_dir: str = "tmp/"
+    browser_log_to_file: bool = False
+    log_dir: Optional[str] = None
+    session_id: Optional[str] = None
+    enabled_tools: Optional[list] = None
+
+
+class ConfigLoader:
+    """Configuration loader for HybridBrowserToolkit."""
+
+    def __init__(
+        self,
+        browser_config: Optional[BrowserConfig] = None,
+        toolkit_config: Optional[ToolkitConfig] = None,
+    ) -> None:
+        self.browser_config = browser_config or BrowserConfig()
+        self.toolkit_config = toolkit_config or ToolkitConfig()
+
+    @classmethod
+    def from_kwargs(cls, **kwargs) -> 'ConfigLoader':
+        """Create ConfigLoader from keyword arguments."""
+        browser_kwargs = {}
+        toolkit_kwargs = {}
+
+        # Map arguments to appropriate config classes
+        browser_fields = set(BrowserConfig.__dataclass_fields__.keys())
+        toolkit_fields = set(ToolkitConfig.__dataclass_fields__.keys())
+
+        for key, value in kwargs.items():
+            # Skip None values to preserve dataclass defaults
+            if value is None:
+                continue
+
+            if key in browser_fields:
+                browser_kwargs[key] = value
+            elif key in toolkit_fields:
+                toolkit_kwargs[key] = value
+            # Handle some common aliases
+            elif key == "userDataDir":
+                browser_kwargs["user_data_dir"] = value
+            elif key == "defaultStartUrl":
+                browser_kwargs["default_start_url"] = value
+            elif key == "navigationTimeout":
+                browser_kwargs["navigation_timeout"] = value
+            elif key == "networkIdleTimeout":
+                browser_kwargs["network_idle_timeout"] = value
+            elif key == "screenshotTimeout":
+                browser_kwargs["screenshot_timeout"] = value
+            elif key == "pageStabilityTimeout":
+                browser_kwargs["page_stability_timeout"] = value
+            elif key == "domContentLoadedTimeout":
+                browser_kwargs["dom_content_loaded_timeout"] = value
+            elif key == "viewportLimit":
+                browser_kwargs["viewport_limit"] = value
+            elif key == "connectOverCdp":
+                browser_kwargs["connect_over_cdp"] = value
+            elif key == "cdpUrl":
+                browser_kwargs["cdp_url"] = value
+            elif key == "cdpKeepCurrentPage":
+                browser_kwargs["cdp_keep_current_page"] = value
+            elif key == "consoleLogLimit":
+                browser_kwargs["console_log_limit"] = value
+            elif key == "cacheDir":
+                toolkit_kwargs["cache_dir"] = value
+            elif key == "browserLogToFile":
+                toolkit_kwargs["browser_log_to_file"] = value
+            elif key == "sessionId":
+                toolkit_kwargs["session_id"] = value
+            elif key == "enabledTools":
+                toolkit_kwargs["enabled_tools"] = value
+            elif key == "fullVisualMode":
+                browser_kwargs["full_visual_mode"] = value
+
+        browser_config = BrowserConfig(**browser_kwargs)
+        toolkit_config = ToolkitConfig(**toolkit_kwargs)
+
+        return cls(browser_config, toolkit_config)
+
+    def get_browser_config(self) -> BrowserConfig:
+        """Get browser configuration."""
+        return self.browser_config
+
+    def get_toolkit_config(self) -> ToolkitConfig:
+        """Get toolkit configuration."""
+        return self.toolkit_config
+
+    def to_ws_config(self) -> Dict[str, Any]:
+        """Convert to WebSocket wrapper configuration format."""
+        return {
+            "headless": self.browser_config.headless,
+            "userDataDir": self.browser_config.user_data_dir,
+            "stealth": self.browser_config.stealth,
+            "defaultStartUrl": self.browser_config.default_start_url,
+            "navigationTimeout": self.browser_config.navigation_timeout,
+            "networkIdleTimeout": self.browser_config.network_idle_timeout,
+            "screenshotTimeout": self.browser_config.screenshot_timeout,
+            "pageStabilityTimeout": self.browser_config.page_stability_timeout,
+            "browser_log_to_file": self.toolkit_config.browser_log_to_file,
+            "log_dir": self.toolkit_config.log_dir,
+            "session_id": self.toolkit_config.session_id,
+            "viewport_limit": self.browser_config.viewport_limit,
+            "connectOverCdp": self.browser_config.connect_over_cdp,
+            "cdpUrl": self.browser_config.cdp_url,
+            "cdpKeepCurrentPage": self.browser_config.cdp_keep_current_page,
+            "fullVisualMode": self.browser_config.full_visual_mode,
+        }
+
+    def get_timeout_config(self) -> Dict[str, Optional[int]]:
+        """Get all timeout configurations."""
+        return {
+            "default_timeout": self.browser_config.default_timeout,
+            "short_timeout": self.browser_config.short_timeout,
+            "navigation_timeout": self.browser_config.navigation_timeout,
+            "network_idle_timeout": self.browser_config.network_idle_timeout,
+            "screenshot_timeout": self.browser_config.screenshot_timeout,
+            "page_stability_timeout": self.browser_config.page_stability_timeout,  # noqa:E501
+            "dom_content_loaded_timeout": self.browser_config.dom_content_loaded_timeout,  # noqa:E501
+        }
+
+    def update_browser_config(self, **kwargs) -> None:
+        """Update browser configuration."""
+        for key, value in kwargs.items():
+            if hasattr(self.browser_config, key):
+                setattr(self.browser_config, key, value)
+
+    def update_toolkit_config(self, **kwargs) -> None:
+        """Update toolkit configuration."""
+        for key, value in kwargs.items():
+            if hasattr(self.toolkit_config, key):
+                setattr(self.toolkit_config, key, value)

camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit.py

@@ -0,0 +1,246 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+from typing import Any, List, Literal, Optional
+
+from camel.toolkits.base import BaseToolkit
+
+
+class HybridBrowserToolkit(BaseToolkit):
+    r"""A hybrid browser toolkit that can switch between TypeScript and Python
+    implementations.
+
+    This wrapper allows users to choose between:
+    - 'typescript': WebSocket-based implementation using TypeScript/Node.js
+    - 'python': Pure Python implementation using Playwright directly
+
+    Args:
+        mode (Literal["typescript", "python"]): Implementation mode. -
+            'typescript': Uses WebSocket-based TypeScript implementation -
+            'python': Uses pure Python Playwright implementation. Defaults to
+            "typescript".
+        headless (bool): Whether to run browser in headless mode.
+            Defaults to True.
+        user_data_dir (Optional[str]): Directory for user data
+            persistence. Defaults to None.
+        stealth (bool): Whether to enable stealth mode. Defaults to
+            False.
+        cache_dir (str): Directory for caching. Defaults to "tmp/".
+        enabled_tools (Optional[List[str]]): List of enabled tools.
+            Defaults to None.
+        browser_log_to_file (bool): Whether to log browser actions to
+            file. Defaults to False.
+        log_dir (Optional[str]): Custom directory path for log files.
+            If None, defaults to "browser_log". Defaults to None.
+        session_id (Optional[str]): Session identifier. Defaults to None.
+        default_start_url (str): Default URL to start with. Defaults
+            to "https://google.com/".
+        default_timeout (Optional[int]): Default timeout in
+            milliseconds. Defaults to None.
+        short_timeout (Optional[int]): Short timeout in milliseconds.
+            Defaults to None.
+        navigation_timeout (Optional[int]): Navigation timeout in
+            milliseconds. Defaults to None.
+        network_idle_timeout (Optional[int]): Network idle timeout in
+            milliseconds. Defaults to None.
+        screenshot_timeout (Optional[int]): Screenshot timeout in
+            milliseconds. Defaults to None.
+        page_stability_timeout (Optional[int]): Page stability timeout
+            in milliseconds. Defaults to None.
+        dom_content_loaded_timeout (Optional[int]): DOM content loaded
+            timeout in milliseconds. Defaults to None.
+        viewport_limit (bool): Whether to filter page snapshot
+            elements to only those visible in the current viewport.
+            Defaults to False.
+        connect_over_cdp (bool): Whether to connect to an existing
+            browser via Chrome DevTools Protocol. Defaults to False.
+            (Only supported in TypeScript mode)
+        cdp_url (Optional[str]): WebSocket endpoint URL for CDP
+            connection. Required when connect_over_cdp is True.
+            Defaults to None. (Only supported in TypeScript mode)
+        cdp_keep_current_page (bool): When True and using CDP mode,
+        won't create new pages but use the existing one. Defaults to False.
+            (Only supported in TypeScript mode)
+        full_visual_mode (bool): When True, browser actions like click,
+            browser_open, visit_page, etc. will return 'full visual mode'
+            as snapshot instead of actual page content. The
+            browser_get_page_snapshot method will still return the actual
+            snapshot. Defaults to False.
+        **kwargs: Additional keyword arguments passed to the
+            implementation.
+
+    Returns:
+        HybridBrowserToolkit instance of the specified implementation.
+    """
+
+    def __new__(
+        cls,
+        *,
+        mode: Literal["typescript", "python"] = "typescript",
+        headless: bool = True,
+        user_data_dir: Optional[str] = None,
+        stealth: bool = False,
+        cache_dir: Optional[str] = None,
+        enabled_tools: Optional[List[str]] = None,
+        browser_log_to_file: bool = False,
+        log_dir: Optional[str] = None,
+        session_id: Optional[str] = None,
+        default_start_url: Optional[str] = None,
+        default_timeout: Optional[int] = None,
+        short_timeout: Optional[int] = None,
+        navigation_timeout: Optional[int] = None,
+        network_idle_timeout: Optional[int] = None,
+        screenshot_timeout: Optional[int] = None,
+        page_stability_timeout: Optional[int] = None,
+        dom_content_loaded_timeout: Optional[int] = None,
+        viewport_limit: bool = False,
+        connect_over_cdp: bool = False,
+        cdp_url: Optional[str] = None,
+        cdp_keep_current_page: bool = False,
+        full_visual_mode: bool = False,
+        **kwargs: Any,
+    ) -> Any:
+        r"""Create a HybridBrowserToolkit instance with the specified mode.
+
+        Args:
+            mode (Literal["typescript", "python"]): Implementation mode.
+                - 'typescript': Uses WebSocket-based TypeScript implementation
+                - 'python': Uses pure Python Playwright implementation
+                Defaults to "typescript".
+            headless (bool): Whether to run browser in headless mode.
+                Defaults to True.
+            user_data_dir (Optional[str]): Directory for user data
+                persistence. Defaults to None.
+            stealth (bool): Whether to enable stealth mode. Defaults to
+                False.
+            cache_dir (str): Directory for caching. Defaults to "tmp/".
+            enabled_tools (Optional[List[str]]): List of enabled tools.
+                Defaults to None.
+            browser_log_to_file (bool): Whether to log browser actions to
+                file. Defaults to False.
+            log_dir (Optional[str]): Custom directory path for log files.
+                If None, defaults to "browser_log". Defaults to None.
+            session_id (Optional[str]): Session identifier. Defaults to None.
+            default_start_url (str): Default URL to start with. Defaults
+                to "https://google.com/".
+            default_timeout (Optional[int]): Default timeout in
+                milliseconds. Defaults to None.
+            short_timeout (Optional[int]): Short timeout in milliseconds.
+                Defaults to None.
+            navigation_timeout (Optional[int]): Navigation timeout in
+                milliseconds. Defaults to None.
+            network_idle_timeout (Optional[int]): Network idle timeout in
+                milliseconds. Defaults to None.
+            screenshot_timeout (Optional[int]): Screenshot timeout in
+                milliseconds. Defaults to None.
+            page_stability_timeout (Optional[int]): Page stability timeout
+                in milliseconds. Defaults to None.
+            dom_content_loaded_timeout (Optional[int]): DOM content loaded
+                timeout in milliseconds. Defaults to None.
+            viewport_limit (bool): Whether to filter page snapshot
+                elements to only those visible in the current viewport.
+                Defaults to False.
+            connect_over_cdp (bool): Whether to connect to an existing
+                browser via Chrome DevTools Protocol. Defaults to False.
+                (Only supported in TypeScript mode)
+            cdp_url (Optional[str]): WebSocket endpoint URL for CDP
+                connection. Required when connect_over_cdp is True.
+                Defaults to None. (Only supported in TypeScript mode)
+            cdp_keep_current_page (bool): When True and using CDP mode,
+            won't create new pages but use the existing one. Defaults to False.
+                (Only supported in TypeScript mode)
+            full_visual_mode (bool): When True, browser actions like click,
+                browser_open, visit_page, etc. will return 'full visual mode'
+                as snapshot instead of actual page content. The
+                browser_get_page_snapshot method will still return the actual
+                snapshot. Defaults to False.
+            **kwargs: Additional keyword arguments passed to the
+                implementation.
+
+        Returns:
+            HybridBrowserToolkit instance of the specified implementation.
+        """
+        if mode == "typescript":
+            from .hybrid_browser_toolkit_ts import (
+                HybridBrowserToolkit as TSToolkit,
+            )
+
+            return TSToolkit(
+                headless=headless,
+                user_data_dir=user_data_dir,
+                stealth=stealth,
+                cache_dir=cache_dir,
+                enabled_tools=enabled_tools,
+                browser_log_to_file=browser_log_to_file,
+                log_dir=log_dir,
+                session_id=session_id,
+                default_start_url=default_start_url,
+                default_timeout=default_timeout,
+                short_timeout=short_timeout,
+                navigation_timeout=navigation_timeout,
+                network_idle_timeout=network_idle_timeout,
+                screenshot_timeout=screenshot_timeout,
+                page_stability_timeout=page_stability_timeout,
+                dom_content_loaded_timeout=dom_content_loaded_timeout,
+                viewport_limit=viewport_limit,
+                connect_over_cdp=connect_over_cdp,
+                cdp_url=cdp_url,
+                cdp_keep_current_page=cdp_keep_current_page,
+                full_visual_mode=full_visual_mode,
+                **kwargs,
+            )
+        elif mode == "python":
+            from ..hybrid_browser_toolkit_py import (
+                HybridBrowserToolkit as PyToolkit,
+            )
+
+            # Note: Python implementation doesn't support CDP connection
+            if connect_over_cdp:
+                raise ValueError(
+                    "CDP connection is only supported in TypeScript mode"
+                )
+
+            # Note: Python implementation doesn't support viewport_limit
+            if viewport_limit:
+                import warnings
+
+                warnings.warn(
+                    "viewport_limit is not supported "
+                    "in Python mode and will be ignored",
+                    UserWarning,
+                )
+
+            return PyToolkit(
+                headless=headless,
+                user_data_dir=user_data_dir,
+                stealth=stealth,
+                cache_dir=cache_dir,
+                enabled_tools=enabled_tools,
+                browser_log_to_file=browser_log_to_file,
+                log_dir=log_dir,
+                session_id=session_id,
+                default_start_url=default_start_url,
+                default_timeout=default_timeout,
+                short_timeout=short_timeout,
+                navigation_timeout=navigation_timeout,
+                network_idle_timeout=network_idle_timeout,
+                screenshot_timeout=screenshot_timeout,
+                page_stability_timeout=page_stability_timeout,
+                dom_content_loaded_timeout=dom_content_loaded_timeout,
+                **kwargs,
+            )
+        else:
+            raise ValueError(
+                f"Invalid mode: {mode}. Must be 'typescript' or 'python'."
+            )