agno 2.2.13__py3-none-any.whl

agno/tools/browserbase.py

@@ -0,0 +1,209 @@
+import json
+from os import getenv
+from typing import Any, Dict, List, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, logger
+
+try:
+    from browserbase import Browserbase
+except ImportError:
+    raise ImportError("`browserbase` not installed. Please install using `pip install browserbase`")
+
+try:
+    from playwright.sync_api import sync_playwright
+except ImportError:
+    raise ImportError(
+        "`playwright` not installed. Please install using `pip install playwright` and run `playwright install`"
+    )
+
+
+class BrowserbaseTools(Toolkit):
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        project_id: Optional[str] = None,
+        base_url: Optional[str] = None,
+        enable_navigate_to: bool = True,
+        enable_screenshot: bool = True,
+        enable_get_page_content: bool = True,
+        enable_close_session: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        """Initialize BrowserbaseTools.
+
+        Args:
+            api_key (str, optional): Browserbase API key.
+            project_id (str, optional): Browserbase project ID.
+            base_url (str, optional): Custom Browserbase API endpoint URL (NOT the target website URL). Only use this if you're using a self-hosted Browserbase instance or need to connect to a different region.
+        """
+        self.api_key = api_key or getenv("BROWSERBASE_API_KEY")
+        if not self.api_key:
+            raise ValueError(
+                "BROWSERBASE_API_KEY is required. Please set the BROWSERBASE_API_KEY environment variable."
+            )
+
+        self.project_id = project_id or getenv("BROWSERBASE_PROJECT_ID")
+        if not self.project_id:
+            raise ValueError(
+                "BROWSERBASE_PROJECT_ID is required. Please set the BROWSERBASE_PROJECT_ID environment variable."
+            )
+
+        self.base_url = base_url or getenv("BROWSERBASE_BASE_URL")
+
+        # Initialize the Browserbase client with optional base_url
+        if self.base_url:
+            self.app = Browserbase(api_key=self.api_key, base_url=self.base_url)
+            log_debug(f"Using custom Browserbase API endpoint: {self.base_url}")
+        else:
+            self.app = Browserbase(api_key=self.api_key)
+
+        self._playwright = None
+        self._browser = None
+        self._page = None
+        self._session = None
+        self._connect_url = None
+
+        tools: List[Any] = []
+        if all or enable_navigate_to:
+            tools.append(self.navigate_to)
+        if all or enable_screenshot:
+            tools.append(self.screenshot)
+        if all or enable_get_page_content:
+            tools.append(self.get_page_content)
+        if all or enable_close_session:
+            tools.append(self.close_session)
+
+        super().__init__(name="browserbase_tools", tools=tools, **kwargs)
+
+    def _ensure_session(self):
+        """Ensures a session exists, creating one if needed."""
+        if not self._session:
+            try:
+                self._session = self.app.sessions.create(project_id=self.project_id)  # type: ignore
+                self._connect_url = self._session.connect_url if self._session else ""  # type: ignore
+                if self._session:
+                    log_debug(f"Created new session with ID: {self._session.id}")
+            except Exception as e:
+                logger.error(f"Failed to create session: {str(e)}")
+                raise
+
+    def _initialize_browser(self, connect_url: Optional[str] = None):
+        """
+        Initialize browser connection if not already initialized.
+        Use provided connect_url or ensure we have a session with a connect_url
+        """
+        if connect_url:
+            self._connect_url = connect_url if connect_url else ""  # type: ignore
+        elif not self._connect_url:
+            self._ensure_session()
+
+        if not self._playwright:
+            self._playwright = sync_playwright().start()  # type: ignore
+            if self._playwright:
+                self._browser = self._playwright.chromium.connect_over_cdp(self._connect_url)
+            context = self._browser.contexts[0] if self._browser else ""
+            self._page = context.pages[0] or context.new_page()  # type: ignore
+
+    def _cleanup(self):
+        """Clean up browser resources."""
+        if self._browser:
+            self._browser.close()
+            self._browser = None
+        if self._playwright:
+            self._playwright.stop()
+            self._playwright = None
+        self._page = None
+
+    def _create_session(self) -> Dict[str, str]:
+        """Creates a new browser session.
+
+        Returns:
+            Dictionary containing session details including session_id and connect_url.
+        """
+        self._ensure_session()
+        return {
+            "session_id": self._session.id if self._session else "",
+            "connect_url": self._session.connect_url if self._session else "",
+        }
+
+    def navigate_to(self, url: str, connect_url: Optional[str] = None) -> str:
+        """Navigates to a URL.
+
+        Args:
+            url (str): The URL to navigate to
+            connect_url (str, optional): The connection URL from an existing session
+
+        Returns:
+            JSON string with navigation status
+        """
+        try:
+            self._initialize_browser(connect_url)
+            if self._page:
+                self._page.goto(url, wait_until="networkidle")
+            result = {"status": "complete", "title": self._page.title() if self._page else "", "url": url}
+            return json.dumps(result)
+        except Exception as e:
+            self._cleanup()
+            raise e
+
+    def screenshot(self, path: str, full_page: bool = True, connect_url: Optional[str] = None) -> str:
+        """Takes a screenshot of the current page.
+
+        Args:
+            path (str): Where to save the screenshot
+            full_page (bool): Whether to capture the full page
+            connect_url (str, optional): The connection URL from an existing session
+
+        Returns:
+            JSON string confirming screenshot was saved
+        """
+        try:
+            self._initialize_browser(connect_url)
+            if self._page:
+                self._page.screenshot(path=path, full_page=full_page)
+            return json.dumps({"status": "success", "path": path})
+        except Exception as e:
+            self._cleanup()
+            raise e
+
+    def get_page_content(self, connect_url: Optional[str] = None) -> str:
+        """Gets the HTML content of the current page.
+
+        Args:
+            connect_url (str, optional): The connection URL from an existing session
+
+        Returns:
+            The page HTML content
+        """
+        try:
+            self._initialize_browser(connect_url)
+            return self._page.content() if self._page else ""
+        except Exception as e:
+            self._cleanup()
+            raise e
+
+    def close_session(self) -> str:
+        """Closes a browser session.
+        Args:
+            session_id (str, optional): The session ID to close. If not provided, will use the current session.
+        Returns:
+            JSON string with closure status
+        """
+        try:
+            # First cleanup our local browser resources
+            self._cleanup()
+
+            # Reset session state
+            self._session = None
+            self._connect_url = None
+
+            return json.dumps(
+                {
+                    "status": "closed",
+                    "message": "Browser resources cleaned up. Session will auto-close if not already closed.",
+                }
+            )
+        except Exception as e:
+            return json.dumps({"status": "warning", "message": f"Cleanup completed with warning: {str(e)}"})

agno/tools/calcom.py

@@ -0,0 +1,255 @@
+from datetime import datetime
+from os import getenv
+from typing import Any, Dict, List, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import logger
+
+try:
+    import pytz
+    import requests
+except ImportError:
+    raise ImportError("`requests` and `pytz` not installed. Please install using `pip install requests pytz`")
+
+
+class CalComTools(Toolkit):
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        event_type_id: Optional[int] = None,
+        user_timezone: Optional[str] = None,
+        # Enable flags for <6 functions
+        enable_get_available_slots: bool = True,
+        enable_create_booking: bool = True,
+        enable_get_upcoming_bookings: bool = True,
+        enable_reschedule_booking: bool = True,
+        enable_cancel_booking: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        """Initialize the Cal.com toolkit.
+
+        Args:
+            api_key: Cal.com API key
+            event_type_id: Default event type ID for bookings
+            user_timezone: User's timezone in IANA format (e.g., 'Asia/Kolkata')
+        """
+
+        # Get credentials from environment if not provided
+        self.api_key = api_key or getenv("CALCOM_API_KEY")
+        event_type_str = getenv("CALCOM_EVENT_TYPE_ID")
+        if event_type_id is not None:
+            self.event_type_id = int(event_type_id)
+        else:
+            self.event_type_id = int(event_type_str) if event_type_str is not None else 0
+
+        if not self.api_key:
+            logger.error("CALCOM_API_KEY not set. Please set the CALCOM_API_KEY environment variable.")
+        if not self.event_type_id:
+            logger.error("CALCOM_EVENT_TYPE_ID not set. Please set the CALCOM_EVENT_TYPE_ID environment variable.")
+
+        self.user_timezone = user_timezone or "America/New_York"
+
+        tools: List[Any] = []
+        if all or enable_get_available_slots:
+            tools.append(self.get_available_slots)
+        if all or enable_create_booking:
+            tools.append(self.create_booking)
+        if all or enable_get_upcoming_bookings:
+            tools.append(self.get_upcoming_bookings)
+        if all or enable_reschedule_booking:
+            tools.append(self.reschedule_booking)
+        if all or enable_cancel_booking:
+            tools.append(self.cancel_booking)
+
+        super().__init__(name="calcom", tools=tools, **kwargs)
+
+    def _convert_to_user_timezone(self, utc_time: str) -> str:
+        """Convert UTC time to user's timezone.
+
+        Args:
+            utc_time: UTC time string
+            user_timezone: User's timezone (e.g., 'Asia/Kolkata')
+
+        Returns:
+            str: Formatted time in user's timezone
+        """
+        utc_dt = datetime.fromisoformat(utc_time.replace("Z", "+00:00"))
+        user_tz = pytz.timezone(self.user_timezone)
+        user_dt = utc_dt.astimezone(user_tz)
+        return user_dt.strftime("%Y-%m-%d %H:%M %Z")
+
+    def _get_headers(self, api_version: str = "2024-08-13") -> Dict[str, str]:
+        """Get headers for Cal.com API requests.
+
+        Args:
+            api_version: Cal.com API version
+
+        Returns:
+            Dict[str, str]: Headers dictionary
+        """
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "cal-api-version": api_version,
+            "Content-Type": "application/json",
+        }
+
+    def get_available_slots(
+        self,
+        start_date: str,
+        end_date: str,
+    ) -> str:
+        """Get available time slots for booking.
+
+        Args:
+            start_date: Start date in YYYY-MM-DD format
+            end_date: End date in YYYY-MM-DD format
+            user_timezone: User's timezone
+            event_type_id: Optional specific event type ID
+
+        Returns:
+            str: Available slots or error message
+        """
+        try:
+            url = "https://api.cal.com/v2/slots/available"
+            querystring = {
+                "startTime": f"{start_date}T00:00:00Z",
+                "endTime": f"{end_date}T23:59:59Z",
+                "eventTypeId": str(self.event_type_id),
+            }
+
+            response = requests.get(url, headers=self._get_headers(), params=querystring)  # type: ignore
+            if response.status_code == 200:
+                slots = response.json()["data"]["slots"]
+                available_slots = []
+                for date, times in slots.items():
+                    for slot in times:
+                        user_time = self._convert_to_user_timezone(slot["time"])
+                        available_slots.append(user_time)
+                return f"Available slots: {', '.join(available_slots)}"
+            return f"Failed to fetch slots: {response.text}"
+        except Exception as e:
+            logger.error(f"Error fetching available slots: {e}")
+            return f"Error: {str(e)}"
+
+    def create_booking(
+        self,
+        start_time: str,
+        name: str,
+        email: str,
+    ) -> str:
+        """Create a new booking.
+
+        Args:
+            start_time: Start time in YYYY-MM-DDTHH:MM:SSZ format
+            name: Attendee's name
+            email: Attendee's email
+
+        Returns:
+            str: Booking confirmation or error message
+        """
+        try:
+            url = "https://api.cal.com/v2/bookings"
+            start_time = datetime.fromisoformat(start_time).astimezone(pytz.utc).isoformat(timespec="seconds")
+            payload = {
+                "start": start_time,
+                "eventTypeId": self.event_type_id,
+                "attendee": {"name": name, "email": email, "timeZone": self.user_timezone},
+            }
+
+            response = requests.post(url, json=payload, headers=self._get_headers())
+            if response.status_code == 201:
+                booking_data = response.json()["data"]
+                user_time = self._convert_to_user_timezone(booking_data["start"])
+                return f"Booking created successfully for {user_time}. Booking uid: {booking_data['uid']}"
+            return f"Failed to create booking: {response.text}"
+        except Exception as e:
+            logger.error(f"Error creating booking: {e}")
+            return f"Error: {str(e)}"
+
+    def get_upcoming_bookings(self, email: Optional[str] = None) -> str:
+        """Get all upcoming bookings for an attendee.
+
+        Args:
+            email (str): Attendee's email [Optional]
+
+        Returns:
+            str: List of upcoming bookings or error message
+        """
+        try:
+            url = "https://api.cal.com/v2/bookings"
+            querystring = {"status": "upcoming"}
+            if email:
+                querystring["attendeeEmail"] = email
+
+            response = requests.get(url, headers=self._get_headers(), params=querystring)
+            if response.status_code == 200:
+                bookings = response.json()["data"]
+                if not bookings:
+                    return "No upcoming bookings found."
+
+                booking_info = []
+                for booking in bookings:
+                    user_time = self._convert_to_user_timezone(booking["start"])
+                    booking_info.append(
+                        f"uid: {booking['uid']}, Title: {booking['title']}, Time: {user_time}, Status: {booking['status']}"
+                    )
+                return "Upcoming bookings:\n" + "\n".join(booking_info)
+            return f"Failed to fetch bookings: {response.text}"
+        except Exception as e:
+            logger.error(f"Error fetching upcoming bookings: {e}")
+            return f"Error: {str(e)}"
+
+    def reschedule_booking(
+        self,
+        booking_uid: str,
+        new_start_time: str,
+        reason: str,
+    ) -> str:
+        """Reschedule an existing booking.
+
+        Args:
+            booking_uid: Booking UID to reschedule
+            new_start_time: New start time in YYYY-MM-DDTHH:MM:SSZ format
+            reason: Reason for rescheduling
+            user_timezone: User's timezone
+
+        Returns:
+            str: Rescheduling confirmation or error message
+        """
+        try:
+            url = f"https://api.cal.com/v2/bookings/{booking_uid}/reschedule"
+            new_start_time = datetime.fromisoformat(new_start_time).astimezone(pytz.utc).isoformat(timespec="seconds")
+            payload = {"start": new_start_time, "reschedulingReason": reason}
+
+            response = requests.post(url, json=payload, headers=self._get_headers())
+            if response.status_code == 201:
+                booking_data = response.json()["data"]
+                user_time = self._convert_to_user_timezone(booking_data["start"])
+                return f"Booking rescheduled to {user_time}. New booking uid: {booking_data['uid']}"
+            return f"Failed to reschedule booking: {response.text}"
+        except Exception as e:
+            logger.error(f"Error rescheduling booking: {e}")
+            return f"Error: {str(e)}"
+
+    def cancel_booking(self, booking_uid: str, reason: str) -> str:
+        """Cancel an existing booking.
+
+        Args:
+            booking_uid: Booking UID to cancel
+            reason: Reason for cancellation
+
+        Returns:
+            str: Cancellation confirmation or error message
+        """
+        try:
+            url = f"https://api.cal.com/v2/bookings/{booking_uid}/cancel"
+            payload = {"cancellationReason": reason}
+
+            response = requests.post(url, json=payload, headers=self._get_headers())
+            if response.status_code == 200:
+                return "Booking cancelled successfully."
+            return f"Failed to cancel booking: {response.text}"
+        except Exception as e:
+            logger.error(f"Error cancelling booking: {e}")
+            return f"Error: {str(e)}"

agno/tools/calculator.py

@@ -0,0 +1,151 @@
+import json
+import math
+from typing import Callable, List
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, logger
+
+
+class CalculatorTools(Toolkit):
+    def __init__(
+        self,
+        **kwargs,
+    ):
+        tools: List[Callable] = [
+            self.add,
+            self.subtract,
+            self.multiply,
+            self.divide,
+            self.exponentiate,
+            self.factorial,
+            self.is_prime,
+            self.square_root,
+        ]
+
+        # Initialize the toolkit with auto-registration enabled
+        super().__init__(name="calculator", tools=tools, **kwargs)
+
+    def add(self, a: float, b: float) -> str:
+        """Add two numbers and return the result.
+
+        Args:
+            a (float): First number.
+            b (float): Second number.
+
+        Returns:
+            str: JSON string of the result.
+        """
+        result = a + b
+        log_debug(f"Adding {a} and {b} to get {result}")
+        return json.dumps({"operation": "addition", "result": result})
+
+    def subtract(self, a: float, b: float) -> str:
+        """Subtract second number from first and return the result.
+
+        Args:
+            a (float): First number.
+            b (float): Second number.
+
+        Returns:
+            str: JSON string of the result.
+        """
+        result = a - b
+        log_debug(f"Subtracting {b} from {a} to get {result}")
+        return json.dumps({"operation": "subtraction", "result": result})
+
+    def multiply(self, a: float, b: float) -> str:
+        """Multiply two numbers and return the result.
+
+        Args:
+            a (float): First number.
+            b (float): Second number.
+
+        Returns:
+            str: JSON string of the result.
+        """
+        result = a * b
+        log_debug(f"Multiplying {a} and {b} to get {result}")
+        return json.dumps({"operation": "multiplication", "result": result})
+
+    def divide(self, a: float, b: float) -> str:
+        """Divide first number by second and return the result.
+
+        Args:
+            a (float): Numerator.
+            b (float): Denominator.
+
+        Returns:
+            str: JSON string of the result.
+        """
+        if b == 0:
+            logger.error("Attempt to divide by zero")
+            return json.dumps({"operation": "division", "error": "Division by zero is undefined"})
+        try:
+            result = a / b
+        except Exception as e:
+            return json.dumps({"operation": "division", "error": str(e), "result": "Error"})
+        log_debug(f"Dividing {a} by {b} to get {result}")
+        return json.dumps({"operation": "division", "result": result})
+
+    def exponentiate(self, a: float, b: float) -> str:
+        """Raise first number to the power of the second number and return the result.
+
+        Args:
+            a (float): Base.
+            b (float): Exponent.
+
+        Returns:
+            str: JSON string of the result.
+        """
+        result = math.pow(a, b)
+        log_debug(f"Raising {a} to the power of {b} to get {result}")
+        return json.dumps({"operation": "exponentiation", "result": result})
+
+    def factorial(self, n: int) -> str:
+        """Calculate the factorial of a number and return the result.
+
+        Args:
+            n (int): Number to calculate the factorial of.
+
+        Returns:
+            str: JSON string of the result.
+        """
+        if n < 0:
+            logger.error("Attempt to calculate factorial of a negative number")
+            return json.dumps({"operation": "factorial", "error": "Factorial of a negative number is undefined"})
+        result = math.factorial(n)
+        log_debug(f"Calculating factorial of {n} to get {result}")
+        return json.dumps({"operation": "factorial", "result": result})
+
+    def is_prime(self, n: int) -> str:
+        """Check if a number is prime and return the result.
+
+        Args:
+            n (int): Number to check if prime.
+
+        Returns:
+            str: JSON string of the result.
+        """
+        if n <= 1:
+            return json.dumps({"operation": "prime_check", "result": False})
+        for i in range(2, int(math.sqrt(n)) + 1):
+            if n % i == 0:
+                return json.dumps({"operation": "prime_check", "result": False})
+        return json.dumps({"operation": "prime_check", "result": True})
+
+    def square_root(self, n: float) -> str:
+        """Calculate the square root of a number and return the result.
+
+        Args:
+            n (float): Number to calculate the square root of.
+
+        Returns:
+            str: JSON string of the result.
+        """
+        if n < 0:
+            logger.error("Attempt to calculate square root of a negative number")
+            return json.dumps({"operation": "square_root", "error": "Square root of a negative number is undefined"})
+
+        result = math.sqrt(n)
+        log_debug(f"Calculating square root of {n} to get {result}")
+        return json.dumps({"operation": "square_root", "result": result})