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

agno/tools/sql.py

@@ -2,7 +2,7 @@ import json
 from typing import Any, Dict, List, Optional
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_debug, logger
 
 try:
     from sqlalchemy import Engine, create_engine
@@ -25,12 +25,12 @@ class SQLTools(Toolkit):
         schema: Optional[str] = None,
         dialect: Optional[str] = None,
         tables: Optional[Dict[str, Any]] = None,
-        list_tables: bool = True,
-        describe_table: bool = True,
-        run_sql_query: bool = True,
+        enable_list_tables: bool = True,
+        enable_describe_table: bool = True,
+        enable_run_sql_query: bool = True,
+        all: bool = False,
+        **kwargs,
     ):
-        super().__init__(name="sql_tools")
-
         # Get the database engine
         _engine: Optional[Engine] = db_engine
         if _engine is None and db_url is not None:
@@ -48,16 +48,20 @@ class SQLTools(Toolkit):
         self.db_engine: Engine = _engine
         self.Session: sessionmaker[Session] = sessionmaker(bind=self.db_engine)
 
+        self.schema = schema
+
         # Tables this toolkit can access
         self.tables: Optional[Dict[str, Any]] = tables
 
-        # Register functions in the toolkit
-        if list_tables:
-            self.register(self.list_tables)
-        if describe_table:
-            self.register(self.describe_table)
-        if run_sql_query:
-            self.register(self.run_sql_query)
+        tools: List[Any] = []
+        if enable_list_tables or all:
+            tools.append(self.list_tables)
+        if enable_describe_table or all:
+            tools.append(self.describe_table)
+        if enable_run_sql_query or all:
+            tools.append(self.run_sql_query)
+
+        super().__init__(name="sql_tools", tools=tools, **kwargs)
 
     def list_tables(self) -> str:
         """Use this function to get a list of table names in the database.
@@ -69,8 +73,13 @@ class SQLTools(Toolkit):
             return json.dumps(self.tables)
 
         try:
-            table_names = inspect(self.db_engine).get_table_names()
-            logger.debug(f"table_names: {table_names}")
+            log_debug("listing tables in the database")
+            inspector = inspect(self.db_engine)
+            if self.schema:
+                table_names = inspector.get_table_names(schema=self.schema)
+            else:
+                table_names = inspector.get_table_names()
+            log_debug(f"table_names: {table_names}")
             return json.dumps(table_names)
         except Exception as e:
             logger.error(f"Error getting tables: {e}")
@@ -87,9 +96,15 @@ class SQLTools(Toolkit):
         """
 
         try:
-            table_names = inspect(self.db_engine)
-            table_schema = table_names.get_columns(table_name)
-            return json.dumps([str(column) for column in table_schema])
+            log_debug(f"Describing table: {table_name}")
+            inspector = inspect(self.db_engine)
+            table_schema = inspector.get_columns(table_name, schema=self.schema)
+            return json.dumps(
+                [
+                    {"name": column["name"], "type": str(column["type"]), "nullable": column["nullable"]}
+                    for column in table_schema
+                ]
+            )
         except Exception as e:
             logger.error(f"Error getting table schema: {e}")
             return f"Error getting table schema: {e}"
@@ -122,7 +137,7 @@ class SQLTools(Toolkit):
         Returns:
             List[dict]: The result of the query.
         """
-        logger.debug(f"Running sql |\n{sql}")
+        log_debug(f"Running sql |\n{sql}")
 
         with self.Session() as sess, sess.begin():
             result = sess.execute(text(sql))

agno/tools/tavily.py

@@ -1,6 +1,6 @@
 import json
 from os import getenv
-from typing import Any, Dict, Literal, Optional
+from typing import Any, Dict, List, Literal, Optional
 
 from agno.tools import Toolkit
 from agno.utils.log import logger
@@ -15,30 +15,67 @@ class TavilyTools(Toolkit):
     def __init__(
         self,
         api_key: Optional[str] = None,
-        search: bool = True,
+        enable_search: bool = True,
+        enable_search_context: bool = False,
+        enable_extract: bool = False,
+        all: bool = False,
         max_tokens: int = 6000,
         include_answer: bool = True,
         search_depth: Literal["basic", "advanced"] = "advanced",
+        extract_depth: Literal["basic", "advanced"] = "basic",
+        include_images: bool = False,
+        include_favicon: bool = False,
+        extract_timeout: Optional[int] = None,
+        extract_format: Literal["markdown", "text"] = "markdown",
         format: Literal["json", "markdown"] = "markdown",
-        use_search_context: bool = False,
+        **kwargs,
     ):
-        super().__init__(name="tavily_tools")
+        """Initialize TavilyTools with search and extract capabilities.
 
+        Args:
+            api_key: Tavily API key. If not provided, will use TAVILY_API_KEY env var.
+            enable_search: Enable web search functionality. Defaults to True.
+            enable_search_context: Use search context mode instead of regular search. Defaults to False.
+            enable_extract: Enable URL content extraction functionality. Defaults to False.
+            all: Enable all available tools. Defaults to False.
+            max_tokens: Maximum tokens for search results. Defaults to 6000.
+            include_answer: Include AI-generated answer in search results. Defaults to True.
+            search_depth: Search depth level - basic (1 credit) or advanced (2 credits). Defaults to "advanced".
+            extract_depth: Extract depth level - basic (1 credit/5 URLs) or advanced (2 credits/5 URLs). Defaults to "basic".
+            include_images: Include images in extracted content. Defaults to False.
+            include_favicon: Include favicon in extracted content. Defaults to False.
+            extract_timeout: Timeout in seconds for extraction requests. Defaults to None.
+            extract_format: Output format for extracted content - markdown or text. Defaults to "markdown".
+            format: Output format for search results - json or markdown. Defaults to "markdown".
+            **kwargs: Additional arguments passed to Toolkit.
+        """
         self.api_key = api_key or getenv("TAVILY_API_KEY")
         if not self.api_key:
             logger.error("TAVILY_API_KEY not provided")
 
         self.client: TavilyClient = TavilyClient(api_key=self.api_key)
         self.search_depth: Literal["basic", "advanced"] = search_depth
+        self.extract_depth: Literal["basic", "advanced"] = extract_depth
         self.max_tokens: int = max_tokens
         self.include_answer: bool = include_answer
+        self.include_images: bool = include_images
+        self.include_favicon: bool = include_favicon
+        self.extract_timeout: Optional[int] = extract_timeout
+        self.extract_format: Literal["markdown", "text"] = extract_format
         self.format: Literal["json", "markdown"] = format
 
-        if search:
-            if use_search_context:
-                self.register(self.web_search_with_tavily)
+        tools: List[Any] = []
+
+        if enable_search or all:
+            if enable_search_context:
+                tools.append(self.web_search_with_tavily)
             else:
-                self.register(self.web_search_using_tavily)
+                tools.append(self.web_search_using_tavily)
+
+        if enable_extract or all:
+            tools.append(self.extract_url_content)
+
+        super().__init__(name="tavily_tools", tools=tools, **kwargs)
 
     def web_search_using_tavily(self, query: str, max_results: int = 5) -> str:
         """Use this function to search the web for a given query.
@@ -102,3 +139,116 @@ class TavilyTools(Toolkit):
         return self.client.get_search_context(
             query=query, search_depth=self.search_depth, max_tokens=self.max_tokens, include_answer=self.include_answer
         )
+
+    def extract_url_content(self, urls: str) -> str:
+        """Extract content from one or more URLs using Tavily's Extract API.
+        This function retrieves the main content from web pages in markdown or text format.
+
+        Args:
+            urls (str): Single URL or multiple comma-separated URLs to extract content from.
+                       Example: "https://example.com" or "https://example.com,https://another.com"
+
+        Returns:
+            str: Extracted content in the specified format (markdown or text).
+                 For multiple URLs, returns combined content with URL headers.
+                 Failed extractions are noted in the output.
+        """
+        # Parse URLs - handle both single and comma-separated multiple URLs
+        url_list = [url.strip() for url in urls.split(",") if url.strip()]
+
+        if not url_list:
+            return "Error: No valid URLs provided."
+
+        try:
+            # Prepare extract parameters
+            extract_params: Dict[str, Any] = {
+                "urls": url_list,
+                "depth": self.extract_depth,
+            }
+
+            # Add optional parameters if specified
+            if self.include_images:
+                extract_params["include_images"] = True
+            if self.include_favicon:
+                extract_params["include_favicon"] = True
+            if self.extract_timeout is not None:
+                extract_params["timeout"] = self.extract_timeout
+
+            # Call Tavily Extract API
+            response = self.client.extract(**extract_params)
+
+            # Process response based on format preference
+            if not response or "results" not in response:
+                return "Error: No content could be extracted from the provided URL(s)."
+
+            results = response.get("results", [])
+            if not results:
+                return "Error: No content could be extracted from the provided URL(s)."
+
+            # Format output
+            if self.extract_format == "markdown":
+                return self._format_extract_markdown(results)
+            elif self.extract_format == "text":
+                return self._format_extract_text(results)
+            else:
+                # Fallback to JSON if format is unrecognized
+                return json.dumps(results, indent=2)
+
+        except Exception as e:
+            logger.error(f"Error extracting content from URLs: {e}")
+            return f"Error extracting content: {str(e)}"
+
+    def _format_extract_markdown(self, results: List[Dict[str, Any]]) -> str:
+        """Format extraction results as markdown.
+
+        Args:
+            results: List of extraction result dictionaries from Tavily API.
+
+        Returns:
+            str: Formatted markdown content.
+        """
+        output = []
+
+        for result in results:
+            url = result.get("url", "Unknown URL")
+            raw_content = result.get("raw_content", "")
+            failed_reason = result.get("failed_reason")
+
+            if failed_reason:
+                output.append(f"## {url}\n\n **Extraction Failed**: {failed_reason}\n\n")
+            elif raw_content:
+                output.append(f"## {url}\n\n{raw_content}\n\n")
+            else:
+                output.append(f"## {url}\n\n*No content available*\n\n")
+
+        return "".join(output) if output else "No content extracted."
+
+    def _format_extract_text(self, results: List[Dict[str, Any]]) -> str:
+        """Format extraction results as plain text.
+
+        Args:
+            results: List of extraction result dictionaries from Tavily API.
+
+        Returns:
+            str: Formatted plain text content.
+        """
+        output = []
+
+        for result in results:
+            url = result.get("url", "Unknown URL")
+            raw_content = result.get("raw_content", "")
+            failed_reason = result.get("failed_reason")
+
+            output.append(f"URL: {url}")
+            output.append("-" * 80)
+
+            if failed_reason:
+                output.append(f"EXTRACTION FAILED: {failed_reason}")
+            elif raw_content:
+                output.append(raw_content)
+            else:
+                output.append("No content available")
+
+            output.append("\n")
+
+        return "\n".join(output) if output else "No content extracted."

agno/tools/telegram.py

@@ -1,25 +1,34 @@
-import os
-from typing import Optional, Union
+from os import getenv
+from typing import Any, List, Optional, Union
 
 import httpx
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_debug, logger
 
 
 class TelegramTools(Toolkit):
     base_url = "https://api.telegram.org"
 
-    def __init__(self, chat_id: Union[str, int], token: Optional[str] = None):
-        super().__init__(name="telegram")
-
-        self.token = token or os.getenv("TELEGRAM_TOKEN")
+    def __init__(
+        self,
+        chat_id: Union[str, int],
+        token: Optional[str] = None,
+        enable_send_message: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        self.token = token or getenv("TELEGRAM_TOKEN")
         if not self.token:
             logger.error("TELEGRAM_TOKEN not set. Please set the TELEGRAM_TOKEN environment variable.")
 
         self.chat_id = chat_id
 
-        self.register(self.send_message)
+        tools: List[Any] = []
+        if all or enable_send_message:
+            tools.append(self.send_message)
+
+        super().__init__(name="telegram", tools=tools, **kwargs)
 
     def _call_post_method(self, method, *args, **kwargs):
         return httpx.post(f"{self.base_url}/bot{self.token}/{method}", *args, **kwargs)
@@ -30,6 +39,7 @@ class TelegramTools(Toolkit):
         :param message: The message to send.
         :return: The response from the API.
         """
+        log_debug(f"Sending telegram message: {message}")
         response = self._call_post_method("sendMessage", json={"chat_id": self.chat_id, "text": message})
         try:
             response.raise_for_status()

agno/tools/todoist.py

@@ -0,0 +1,218 @@
+import json
+from os import getenv
+from typing import Any, Dict, List, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import logger
+
+try:
+    from todoist_api_python.api import TodoistAPI
+except ImportError:
+    raise ImportError("`todoist-api-python` not installed. Please install using `pip install todoist-api-python`")
+
+
+class TodoistTools(Toolkit):
+    """A toolkit for interacting with Todoist tasks and projects."""
+
+    def __init__(
+        self,
+        api_token: Optional[str] = None,
+        **kwargs,
+    ):
+        """Initialize the Todoist toolkit.
+
+        Args:
+            api_token: Optional Todoist API token. If not provided, will look for TODOIST_API_TOKEN env var
+        """
+        self.api_token = api_token or getenv("TODOIST_API_TOKEN")
+        if not self.api_token:
+            raise ValueError("TODOIST_API_TOKEN not set. Please set the TODOIST_API_TOKEN environment variable.")
+
+        self.api = TodoistAPI(self.api_token)
+
+        tools: List[Any] = [
+            self.create_task,
+            self.get_task,
+            self.update_task,
+            self.close_task,
+            self.delete_task,
+            self.get_active_tasks,
+            self.get_projects,
+        ]
+
+        super().__init__(name="todoist", tools=tools, **kwargs)
+
+    def _task_to_dict(self, task: Any) -> Dict[str, Any]:
+        """Convert a Todoist task to a dictionary with proper typing."""
+        task_dict: Dict[str, Any] = {
+            "id": task.id,
+            "content": task.content,
+            "description": task.description,
+            "project_id": task.project_id,
+            "section_id": task.section_id,
+            "parent_id": task.parent_id,
+            "order": task.order,
+            "priority": task.priority,
+            "url": task.url,
+            "creator_id": task.creator_id,
+            "created_at": task.created_at,
+            "labels": task.labels,
+        }
+        if hasattr(task, "comment_count"):
+            task_dict["comment_count"] = task.comment_count
+        if task.due:
+            task_dict["due"] = {
+                "date": task.due.date,
+                "string": task.due.string,
+                "lang": task.due.lang,
+                "is_recurring": task.due.is_recurring,
+                "timezone": task.due.timezone,
+            }
+        return task_dict
+
+    def create_task(
+        self,
+        content: str,
+        project_id: Optional[str] = None,
+        due_string: Optional[str] = None,
+        priority: Optional[int] = None,
+        labels: Optional[List[str]] = None,
+    ) -> str:
+        """
+        Create a new task in Todoist.
+
+        Args:
+            content: The task content/description
+            project_id: Optional ID of the project to add the task to
+            due_string: Optional due date in natural language (e.g., "tomorrow at 12:00")
+            priority: Optional priority level (1-4, where 4 is highest)
+            labels: Optional list of label names to apply to the task
+
+        Returns:
+            str: JSON string containing the created task
+        """
+        try:
+            task = self.api.add_task(
+                content=content, project_id=project_id, due_string=due_string, priority=priority, labels=labels or []
+            )
+            # Convert task to a dictionary and handle the Due object
+            task_dict = self._task_to_dict(task)
+            return json.dumps(task_dict, default=str)
+        except Exception as e:
+            logger.error(f"Failed to create task: {str(e)}")
+            return json.dumps({"error": str(e)})
+
+    def get_task(self, task_id: str) -> str:
+        """Get a specific task by ID."""
+        try:
+            task = self.api.get_task(task_id)
+            task_dict = self._task_to_dict(task)
+            return json.dumps(task_dict, default=str)
+        except Exception as e:
+            logger.error(f"Failed to get task: {str(e)}")
+            return json.dumps({"error": str(e)})
+
+    def update_task(
+        self,
+        task_id: str,
+        content: Optional[str] = None,
+        description: Optional[str] = None,
+        labels: Optional[List[str]] = None,
+        priority: Optional[int] = None,
+        due_string: Optional[str] = None,
+        due_date: Optional[str] = None,
+        due_datetime: Optional[str] = None,
+        due_lang: Optional[str] = None,
+        assignee_id: Optional[str] = None,
+        section_id: Optional[str] = None,
+    ) -> str:
+        """
+        Update an existing task with the specified parameters.
+
+        Args:
+            task_id: The ID of the task to update
+            content: The task content/name
+            description: The task description
+            labels: Array of label names
+            priority: Task priority from 1 (normal) to 4 (urgent)
+            due_string: Human readable date ("next Monday", "tomorrow", etc)
+            due_date: Specific date in YYYY-MM-DD format
+            due_datetime: Specific date and time in RFC3339 format
+            due_lang: 2-letter code specifying language of due_string ("en", "fr", etc)
+            assignee_id: The responsible user ID
+            section_id: ID of the section to move task to
+
+        Returns:
+            str: JSON string containing success status or error message
+        """
+        try:
+            # Build updates dictionary with only provided parameters
+            updates: Dict[str, Any] = {}
+            if content is not None:
+                updates["content"] = content
+            if description is not None:
+                updates["description"] = description
+            if labels is not None:
+                updates["labels"] = labels
+            if priority is not None:
+                updates["priority"] = priority
+            if due_string is not None:
+                updates["due_string"] = due_string
+            if due_date is not None:
+                updates["due_date"] = due_date
+            if due_datetime is not None:
+                updates["due_datetime"] = due_datetime
+            if due_lang is not None:
+                updates["due_lang"] = due_lang
+            if assignee_id is not None:
+                updates["assignee_id"] = assignee_id
+            if section_id is not None:
+                updates["section_id"] = section_id
+
+            success = self.api.update_task(task_id=task_id, **updates)
+            return json.dumps({"success": success})
+        except Exception as e:
+            error_msg = str(e)
+            logger.error(f"Failed to update task: {error_msg}")
+            return json.dumps({"error": error_msg})
+
+    def close_task(self, task_id: str) -> str:
+        """Mark a task as completed."""
+        try:
+            success = self.api.complete_task(task_id)
+            return json.dumps({"success": success})
+        except Exception as e:
+            logger.error(f"Failed to close task: {str(e)}")
+            return json.dumps({"error": str(e)})
+
+    def delete_task(self, task_id: str) -> str:
+        """Delete a task."""
+        try:
+            success = self.api.delete_task(task_id)
+            return json.dumps({"success": success})
+        except Exception as e:
+            logger.error(f"Failed to delete task: {str(e)}")
+            return json.dumps({"error": str(e)})
+
+    def get_active_tasks(self) -> str:
+        """Get all active (not completed) tasks."""
+        try:
+            tasks_response = self.api.get_tasks()
+            tasks = list(tasks_response)[0]
+            tasks_list = []
+            for task in tasks:
+                task_dict = self._task_to_dict(task)
+                tasks_list.append(task_dict)
+            return json.dumps(tasks_list, default=str)
+        except Exception as e:
+            logger.error(f"Failed to get active tasks: {str(e)}")
+            return json.dumps({"error": str(e)})
+
+    def get_projects(self) -> str:
+        """Get all projects."""
+        try:
+            projects = self.api.get_projects()
+            return json.dumps([project.__dict__ for project in projects])
+        except Exception as e:
+            logger.error(f"Failed to get projects: {str(e)}")
+            return json.dumps({"error": str(e)})