agno 0.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/tools/zoom.py

@@ -1,10 +1,13 @@
 import json
-from typing import Optional
+from base64 import b64encode
+from datetime import datetime, timedelta
+from os import getenv
+from typing import Any, List, Optional
 
 import requests
 
-from agno.tools.toolkit import Toolkit
-from agno.utils.log import logger
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, log_info, logger
 
 
 class ZoomTools(Toolkit):
@@ -13,37 +16,83 @@ class ZoomTools(Toolkit):
         account_id: Optional[str] = None,
         client_id: Optional[str] = None,
         client_secret: Optional[str] = None,
-        name: str = "zoom_tool",
+        **kwargs,
     ):
         """
         Initialize the ZoomTool.
 
         Args:
-            account_id (str): The Zoom account ID for authentication.
-            client_id (str): The client ID for authentication.
-            client_secret (str): The client secret for authentication.
+            account_id (str): The Zoom account ID for authentication. If not provided, will use ZOOM_ACCOUNT_ID env var.
+            client_id (str): The client ID for authentication. If not provided, will use ZOOM_CLIENT_ID env var.
+            client_secret (str): The client secret for authentication. If not provided, will use ZOOM_CLIENT_SECRET env var.
             name (str): The name of the tool. Defaults to "zoom_tool".
         """
-        super().__init__(name)
-        self.account_id = account_id
-        self.client_id = client_id
-        self.client_secret = client_secret
+        # Get credentials from env vars if not provided
+        self.account_id = account_id or getenv("ZOOM_ACCOUNT_ID")
+        self.client_id = client_id or getenv("ZOOM_CLIENT_ID")
+        self.client_secret = client_secret or getenv("ZOOM_CLIENT_SECRET")
         self.__access_token = None  # Made private
+        self.__token_expiry = None  # Track token expiration
 
         if not self.account_id or not self.client_id or not self.client_secret:
-            logger.error("ZOOM_ACCOUNT_ID, ZOOM_CLIENT_ID, and ZOOM_CLIENT_SECRET must be set.")
-
-        # Register functions
-        self.register(self.schedule_meeting)
-        self.register(self.get_upcoming_meetings)
-        self.register(self.list_meetings)
-        self.register(self.get_meeting_recordings)
-        self.register(self.delete_meeting)
-        self.register(self.get_meeting)
+            logger.error(
+                "ZOOM_ACCOUNT_ID, ZOOM_CLIENT_ID, and ZOOM_CLIENT_SECRET must be set either through parameters or environment variables."
+            )
+
+        tools: List[Any] = [
+            self.get_access_token,
+            self.schedule_meeting,
+            self.get_upcoming_meetings,
+            self.list_meetings,
+            self.get_meeting_recordings,
+            self.delete_meeting,
+            self.get_meeting,
+        ]
+
+        super().__init__(name="zoom_tool", tools=tools, **kwargs)
 
     def get_access_token(self) -> str:
-        """Get the current access token"""
-        return str(self.__access_token) if self.__access_token else ""
+        """
+        Get a valid access token, refreshing if necessary using Zoom's Server-to-Server OAuth.
+
+        Returns:
+            str: The current access token or empty string if token generation fails.
+        """
+        # Check if we have a valid token
+        if self.__access_token and self.__token_expiry and datetime.now() < self.__token_expiry:
+            return self.__access_token
+
+        # Generate new token
+        try:
+            headers = {
+                "Content-Type": "application/x-www-form-urlencoded",
+            }
+
+            # Create base64 encoded auth string
+            auth_string = b64encode(f"{self.client_id}:{self.client_secret}".encode()).decode()
+            headers["Authorization"] = f"Basic {auth_string}"
+
+            data = {
+                "grant_type": "account_credentials",
+                "account_id": self.account_id,
+            }
+
+            response = requests.post("https://zoom.us/oauth/token", headers=headers, data=data)
+            response.raise_for_status()
+
+            token_data = response.json()
+            self.__access_token = token_data["access_token"]
+            # Set expiry time slightly before actual expiry to ensure token validity
+            self.__token_expiry = datetime.now() + timedelta(seconds=token_data["expires_in"] - 60)  # type: ignore
+
+            log_debug("Successfully generated new Zoom access token")
+            return self.__access_token  # type: ignore
+
+        except requests.RequestException as e:
+            logger.error(f"Failed to generate Zoom access token: {e}")
+            self.__access_token = None
+            self.__token_expiry = None
+            return ""
 
     def schedule_meeting(self, topic: str, start_time: str, duration: int, timezone: str = "UTC") -> str:
         """
@@ -59,7 +108,7 @@ class ZoomTools(Toolkit):
             A JSON-formatted string containing the response from Zoom API with the scheduled meeting details,
             or an error message if the scheduling fails.
         """
-        logger.debug(f"Attempting to schedule meeting: {topic} in timezone: {timezone}")
+        log_debug(f"Attempting to schedule meeting: {topic} in timezone: {timezone}")
         token = self.get_access_token()
         if not token:
             logger.error("Unable to obtain access token.")
@@ -97,7 +146,7 @@ class ZoomTools(Toolkit):
                 "duration": meeting_info["duration"],
                 "join_url": meeting_info["join_url"],
             }
-            logger.info(f"Meeting scheduled successfully. ID: {meeting_info['id']}")
+            log_info(f"Meeting scheduled successfully. ID: {meeting_info['id']}")
             return json.dumps(result, indent=2)
         except requests.RequestException as e:
             logger.error(f"Error scheduling meeting: {e}")
@@ -114,7 +163,7 @@ class ZoomTools(Toolkit):
             A JSON-formatted string containing the upcoming meetings information,
             or an error message if the request fails.
         """
-        logger.debug(f"Fetching upcoming meetings for user: {user_id}")
+        log_debug(f"Fetching upcoming meetings for user: {user_id}")
         token = self.get_access_token()
         if not token:
             logger.error("Unable to obtain access token.")
@@ -125,12 +174,12 @@ class ZoomTools(Toolkit):
         params = {"type": "upcoming", "page_size": str(30)}
 
         try:
-            response = requests.get(url, headers=headers, params=params)
+            response = requests.get(url, headers=headers, params=params)  # type: ignore
             response.raise_for_status()
             meetings = response.json()
 
             result = {"message": "Upcoming meetings retrieved successfully", "meetings": meetings.get("meetings", [])}
-            logger.info(f"Retrieved {len(result['meetings'])} upcoming meetings")
+            log_info(f"Retrieved {len(result['meetings'])} upcoming meetings")
             return json.dumps(result, indent=2)
         except requests.RequestException as e:
             logger.error(f"Error fetching upcoming meetings: {e}")
@@ -153,7 +202,7 @@ class ZoomTools(Toolkit):
             A JSON-formatted string containing the meetings information,
             or an error message if the request fails.
         """
-        logger.debug(f"Fetching meetings for user: {user_id}")
+        log_debug(f"Fetching meetings for user: {user_id}")
         token = self.get_access_token()
         if not token:
             logger.error("Unable to obtain access token.")
@@ -176,7 +225,7 @@ class ZoomTools(Toolkit):
                 "total_records": meetings.get("total_records", 0),
                 "meetings": meetings.get("meetings", []),
             }
-            logger.info(f"Retrieved {len(result['meetings'])} meetings")
+            log_info(f"Retrieved {len(result['meetings'])} meetings")
             return json.dumps(result, indent=2)
         except requests.RequestException as e:
             logger.error(f"Error fetching meetings: {e}")
@@ -197,7 +246,7 @@ class ZoomTools(Toolkit):
             A JSON-formatted string containing the meeting recordings information,
             or an error message if the request fails.
         """
-        logger.debug(f"Fetching recordings for meeting: {meeting_id}")
+        log_debug(f"Fetching recordings for meeting: {meeting_id}")
         token = self.get_access_token()
         if not token:
             logger.error("Unable to obtain access token.")
@@ -223,7 +272,7 @@ class ZoomTools(Toolkit):
 
             result = {
                 "message": "Meeting recordings retrieved successfully",
-                "meeting_id": recordings.get("id", ""),
+                "meeting_id": str(recordings.get("id", "")),
                 "uuid": recordings.get("uuid", ""),
                 "host_id": recordings.get("host_id", ""),
                 "topic": recordings.get("topic", ""),
@@ -234,7 +283,7 @@ class ZoomTools(Toolkit):
                 "recording_files": recordings.get("recording_files", []),
             }
 
-            logger.info(f"Retrieved {result['recording_count']} recording files")
+            log_info(f"Retrieved {result['recording_count']} recording files")
             return json.dumps(result, indent=2)
         except requests.RequestException as e:
             logger.error(f"Error fetching meeting recordings: {e}")
@@ -253,7 +302,7 @@ class ZoomTools(Toolkit):
             A JSON-formatted string containing the response status,
             or an error message if the deletion fails.
         """
-        logger.debug(f"Attempting to delete meeting: {meeting_id}")
+        log_debug(f"Attempting to delete meeting: {meeting_id}")
         token = self.get_access_token()
         if not token:
             logger.error("Unable to obtain access token.")
@@ -270,7 +319,7 @@ class ZoomTools(Toolkit):
             # Zoom returns 204 No Content for successful deletion
             if response.status_code == 204:
                 result = {"message": "Meeting deleted successfully!", "meeting_id": meeting_id}
-                logger.info(f"Meeting {meeting_id} deleted successfully")
+                log_info(f"Meeting {meeting_id} deleted successfully")
             else:
                 result = response.json()
 
@@ -290,7 +339,7 @@ class ZoomTools(Toolkit):
             A JSON-formatted string containing the meeting details,
             or an error message if the request fails.
         """
-        logger.debug(f"Fetching details for meeting: {meeting_id}")
+        log_debug(f"Fetching details for meeting: {meeting_id}")
         token = self.get_access_token()
         if not token:
             logger.error("Unable to obtain access token.")
@@ -306,7 +355,7 @@ class ZoomTools(Toolkit):
 
             result = {
                 "message": "Meeting details retrieved successfully",
-                "meeting_id": meeting_info.get("id", ""),
+                "meeting_id": str(meeting_info.get("id", "")),
                 "topic": meeting_info.get("topic", ""),
                 "type": meeting_info.get("type", ""),
                 "start_time": meeting_info.get("start_time", ""),
@@ -317,7 +366,7 @@ class ZoomTools(Toolkit):
                 "settings": meeting_info.get("settings", {}),
             }
 
-            logger.info(f"Retrieved details for meeting ID: {meeting_id}")
+            log_info(f"Retrieved details for meeting ID: {meeting_id}")
             return json.dumps(result, indent=2)
         except requests.RequestException as e:
             logger.error(f"Error fetching meeting details: {e}")

agno/tracing/__init__.py

@@ -0,0 +1,12 @@
+"""
+Agno Tracing Module
+
+This module provides OpenTelemetry-based tracing capabilities for Agno agents.
+It uses the openinference-instrumentation-agno package for automatic instrumentation
+and provides a custom DatabaseSpanExporter to store traces in the Agno database.
+"""
+
+from agno.tracing.exporter import DatabaseSpanExporter
+from agno.tracing.setup import setup_tracing
+
+__all__ = ["DatabaseSpanExporter", "setup_tracing"]

agno/tracing/exporter.py

@@ -0,0 +1,157 @@
+"""
+Custom OpenTelemetry SpanExporter that writes traces to Agno database.
+"""
+
+import asyncio
+from collections import defaultdict
+from typing import Dict, List, Sequence, Union
+
+from opentelemetry.sdk.trace import ReadableSpan  # type: ignore
+from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult  # type: ignore
+
+from agno.db.base import AsyncBaseDb, BaseDb
+from agno.tracing.schemas import Span, create_trace_from_spans
+from agno.utils.log import logger
+
+
+class DatabaseSpanExporter(SpanExporter):
+    """Custom OpenTelemetry SpanExporter that writes to Agno database"""
+
+    def __init__(self, db: Union[BaseDb, AsyncBaseDb]):
+        """
+        Initialize the DatabaseSpanExporter.
+
+        Args:
+            db: Database instance (sync or async) to store traces
+        """
+        self.db = db
+        self._shutdown = False
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        """
+        Export spans to the database.
+
+        This method:
+        1. Converts OpenTelemetry spans to Span objects
+        2. Groups spans by trace_id
+        3. Creates Trace records (one per trace_id)
+        4. Creates Span records (multiple per trace_id)
+
+        Args:
+            spans: Sequence of OpenTelemetry ReadableSpan objects
+
+        Returns:
+            SpanExportResult indicating success or failure
+        """
+        if self._shutdown:
+            logger.warning("DatabaseSpanExporter is shutdown, cannot export spans")
+            return SpanExportResult.FAILURE
+
+        if not spans:
+            return SpanExportResult.SUCCESS
+
+        try:
+            # Convert OpenTelemetry spans to Span objects
+            converted_spans: List[Span] = []
+            for span in spans:
+                try:
+                    converted_span = Span.from_otel_span(span)
+                    converted_spans.append(converted_span)
+                except Exception as e:
+                    logger.error(f"Failed to convert span {span.name}: {e}")
+                    # Continue processing other spans
+                    continue
+
+            if not converted_spans:
+                return SpanExportResult.SUCCESS
+
+            # Group spans by trace_id
+            spans_by_trace: Dict[str, List[Span]] = defaultdict(list)
+            for converted_span in converted_spans:
+                spans_by_trace[converted_span.trace_id].append(converted_span)
+
+            # Handle async DB
+            if isinstance(self.db, AsyncBaseDb):
+                self._export_async(spans_by_trace)
+            else:
+                # Synchronous database
+                self._export_sync(spans_by_trace)
+
+            return SpanExportResult.SUCCESS
+        except Exception as e:
+            logger.error(f"Failed to export spans to database: {e}", exc_info=True)
+            return SpanExportResult.FAILURE
+
+    def _export_sync(self, spans_by_trace: Dict[str, List[Span]]) -> None:
+        """Export traces and spans to synchronous database"""
+        try:
+            # Create trace and span records for each trace
+            for trace_id, spans in spans_by_trace.items():
+                # Create trace record (aggregate of all spans)
+                trace = create_trace_from_spans(spans)
+                if trace:
+                    self.db.upsert_trace(trace)
+
+                # Create span records
+                self.db.create_spans(spans)
+
+        except Exception as e:
+            logger.error(f"Failed to export sync traces: {e}", exc_info=True)
+            raise
+
+    def _export_async(self, spans_by_trace: Dict[str, List[Span]]) -> None:
+        """Handle async database export"""
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # We're in an async context, schedule the coroutine
+                asyncio.create_task(self._do_async_export(spans_by_trace))
+            else:
+                # No running loop, run in new loop
+                loop.run_until_complete(self._do_async_export(spans_by_trace))
+        except RuntimeError:
+            # No event loop, create new one
+            try:
+                asyncio.run(self._do_async_export(spans_by_trace))
+            except Exception as e:
+                logger.error(f"Failed to export async traces: {e}", exc_info=True)
+
+    async def _do_async_export(self, spans_by_trace: Dict[str, List[Span]]) -> None:
+        """Actually perform the async export"""
+        try:
+            # Create trace and span records for each trace
+            for trace_id, spans in spans_by_trace.items():
+                # Create trace record (aggregate of all spans)
+                trace = create_trace_from_spans(spans)
+                if trace:
+                    create_trace_result = self.db.upsert_trace(trace)
+                    if create_trace_result is not None:
+                        await create_trace_result
+
+                # Create span records
+                create_spans_result = self.db.create_spans(spans)
+                if create_spans_result is not None:
+                    await create_spans_result
+
+        except Exception as e:
+            logger.error(f"Failed to do async export: {e}", exc_info=True)
+            raise
+
+    def shutdown(self) -> None:
+        """Shutdown the exporter"""
+        self._shutdown = True
+        logger.debug("DatabaseSpanExporter shutdown")
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        """
+        Force flush any pending spans.
+
+        Since we write immediately to the database, this is a no-op.
+
+        Args:
+            timeout_millis: Timeout in milliseconds
+
+        Returns:
+            True if flush was successful
+        """
+        return True