agno 1.8.1__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

agno/tools/{clickup_tool.py → clickup.py}

@@ -1,6 +1,6 @@
 import json
-import os
 import re
+from os import getenv
 from typing import Any, Dict, List, Optional
 
 from agno.tools import Toolkit
@@ -17,17 +17,10 @@ class ClickUpTools(Toolkit):
         self,
         api_key: Optional[str] = None,
         master_space_id: Optional[str] = None,
-        list_tasks: bool = True,
-        create_task: bool = True,
-        get_task: bool = True,
-        update_task: bool = True,
-        delete_task: bool = True,
-        list_spaces: bool = True,
-        list_lists: bool = True,
         **kwargs,
     ):
-        self.api_key = api_key or os.getenv("CLICKUP_API_KEY")
-        self.master_space_id = master_space_id or os.getenv("MASTER_SPACE_ID")
+        self.api_key = api_key or getenv("CLICKUP_API_KEY")
+        self.master_space_id = master_space_id or getenv("MASTER_SPACE_ID")
         self.base_url = "https://api.clickup.com/api/v2"
         self.headers = {"Authorization": self.api_key}
 
@@ -36,21 +29,15 @@ class ClickUpTools(Toolkit):
         if not self.master_space_id:
             raise ValueError("MASTER_SPACE_ID not set. Please set the MASTER_SPACE_ID environment variable.")
 
-        tools: List[Any] = []
-        if list_tasks:
-            tools.append(self.list_tasks)
-        if create_task:
-            tools.append(self.create_task)
-        if get_task:
-            tools.append(self.get_task)
-        if update_task:
-            tools.append(self.update_task)
-        if delete_task:
-            tools.append(self.delete_task)
-        if list_spaces:
-            tools.append(self.list_spaces)
-        if list_lists:
-            tools.append(self.list_lists)
+        tools: List[Any] = [
+            self.list_tasks,
+            self.create_task,
+            self.get_task,
+            self.update_task,
+            self.delete_task,
+            self.list_spaces,
+            self.list_lists,
+        ]
 
         super().__init__(name="clickup", tools=tools, **kwargs)
 

agno/tools/confluence.py

@@ -39,7 +39,6 @@ class ConfluenceTools(Toolkit):
             - CONFLUENCE_API_KEY
         """
 
-        super().__init__(name="confluence_tools", **kwargs)
         self.url = url or getenv("CONFLUENCE_URL")
         self.username = username or getenv("CONFLUENCE_USERNAME")
         self.password = api_key or getenv("CONFLUENCE_API_KEY") or password or getenv("CONFLUENCE_PASSWORD")
@@ -73,13 +72,14 @@ class ConfluenceTools(Toolkit):
             session=session,
         )
 
-        tools: List[Any] = []
-        tools.append(self.get_page_content)
-        tools.append(self.get_space_key)
-        tools.append(self.create_page)
-        tools.append(self.update_page)
-        tools.append(self.get_all_space_detail)
-        tools.append(self.get_all_page_from_space)
+        tools: List[Any] = [
+            self.get_page_content,
+            self.get_space_key,
+            self.create_page,
+            self.update_page,
+            self.get_all_space_detail,
+            self.get_all_page_from_space,
+        ]
 
         super().__init__(name="confluence_tools", tools=tools, **kwargs)
 

agno/tools/crawl4ai.py

@@ -20,9 +20,15 @@ class Crawl4aiTools(Toolkit):
         bm25_threshold: float = 1.0,
         headless: bool = True,
         wait_until: str = "domcontentloaded",
+        enable_crawl: bool = True,
+        all: bool = False,
         **kwargs,
     ):
-        super().__init__(name="crawl4ai_tools", tools=[self.crawl], **kwargs)
+        tools = []
+        if all or enable_crawl:
+            tools.append(self.crawl)
+
+        super().__init__(name="crawl4ai_tools", tools=tools, **kwargs)
         self.max_length = max_length
         self.timeout = timeout
         self.use_pruning = use_pruning

agno/tools/csv_toolkit.py

@@ -12,12 +12,13 @@ class CsvTools(Toolkit):
         self,
         csvs: Optional[List[Union[str, Path]]] = None,
         row_limit: Optional[int] = None,
-        read_csvs: bool = True,
-        list_csvs: bool = True,
-        query_csvs: bool = True,
-        read_column_names: bool = True,
         duckdb_connection: Optional[Any] = None,
         duckdb_kwargs: Optional[Dict[str, Any]] = None,
+        enable_read_csv_file: bool = True,
+        enable_list_csv_files: bool = True,
+        enable_get_columns: bool = True,
+        enable_query_csv_file: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.csvs: List[Path] = []
@@ -34,13 +35,13 @@ class CsvTools(Toolkit):
         self.duckdb_kwargs: Optional[Dict[str, Any]] = duckdb_kwargs
 
         tools: List[Any] = []
-        if read_csvs:
+        if all or enable_read_csv_file:
             tools.append(self.read_csv_file)
-        if list_csvs:
+        if all or enable_list_csv_files:
             tools.append(self.list_csv_files)
-        if read_column_names:
+        if all or enable_get_columns:
             tools.append(self.get_columns)
-        if query_csvs:
+        if all or enable_query_csv_file:
             try:
                 import duckdb  # noqa: F401
 

agno/tools/dalle.py

@@ -6,6 +6,7 @@ from agno.agent import Agent
 from agno.media import ImageArtifact
 from agno.team.team import Team
 from agno.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import log_debug, logger
 
 try:
@@ -24,6 +25,8 @@ class DalleTools(Toolkit):
         quality: Literal["standard", "hd"] = "standard",
         style: Literal["vivid", "natural"] = "vivid",
         api_key: Optional[str] = None,
+        enable_create_image: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.model = model
@@ -51,7 +54,8 @@ class DalleTools(Toolkit):
             logger.error("OPENAI_API_KEY not set. Please set the OPENAI_API_KEY environment variable.")
 
         tools: List[Any] = []
-        tools.append(self.create_image)
+        if all or enable_create_image:
+            tools.append(self.create_image)
 
         super().__init__(name="dalle", tools=tools, **kwargs)
 
@@ -60,17 +64,17 @@ class DalleTools(Toolkit):
         # - Add support for saving images
         # - Add support for editing images
 
-    def create_image(self, agent: Union[Agent, Team], prompt: str) -> str:
+    def create_image(self, agent: Union[Agent, Team], prompt: str) -> ToolResult:
         """Use this function to generate an image for a prompt.
 
         Args:
             prompt (str): A text description of the desired image.
 
         Returns:
-            str: str: A message indicating if the image has been generated successfully or an error message.
+            ToolResult: Result containing the message and generated images.
         """
         if not self.api_key:
-            return "Please set the OPENAI_API_KEY"
+            return ToolResult(content="Please set the OPENAI_API_KEY")
 
         try:
             client = OpenAI(api_key=self.api_key)
@@ -85,18 +89,21 @@ class DalleTools(Toolkit):
             )
             log_debug("Image generated successfully")
 
-            # Update the run response with the image URLs
+            generated_images = []
             response_str = ""
             if response.data:
                 for img in response.data:
                     if img.url:
-                        agent.add_image(
-                            ImageArtifact(
-                                id=str(uuid4()), url=img.url, original_prompt=prompt, revised_prompt=img.revised_prompt
-                            )
+                        image_artifact = ImageArtifact(
+                            id=str(uuid4()), url=img.url, original_prompt=prompt, revised_prompt=img.revised_prompt
                         )
+                        generated_images.append(image_artifact)
                         response_str += f"Image has been generated at the URL {img.url}\n"
-            return response_str or "No images were generated"
+
+            return ToolResult(
+                content=response_str or "No images were generated",
+                images=generated_images if generated_images else None,
+            )
         except Exception as e:
             logger.error(f"Failed to generate image: {e}")
-            return f"Error: {e}"
+            return ToolResult(content=f"Error: {e}")

agno/tools/daytona.py

@@ -2,7 +2,7 @@ import json
 from os import getenv
 from pathlib import Path
 from textwrap import dedent
-from typing import Dict, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 from agno.agent import Agent
 from agno.team import Team
@@ -24,7 +24,6 @@ except ImportError:
 DEFAULT_INSTRUCTIONS = dedent(
     """\
     You have access to a persistent Daytona sandbox for code execution. The sandbox maintains state across interactions.
-    
     Available tools:
     - `run_code`: Execute code in the sandbox
     - `run_shell_command`: Execute shell commands (bash)
@@ -33,21 +32,19 @@ DEFAULT_INSTRUCTIONS = dedent(
     - `list_files`: List directory contents
     - `delete_file`: Delete files or directories
     - `change_directory`: Change the working directory
-    
     MANDATORY: When users ask for code (Python, JavaScript, TypeScript, etc.), you MUST:
     1. Write the code
     2. Execute it using run_code tool
     3. Show the actual output/results
     4. Never just provide code without executing it
-    
     CRITICAL WORKFLOW:
     1. Before running Python scripts, check if required packages are installed
     2. Install missing packages with: run_shell_command("pip install package1 package2")
     3. When running scripts, capture both output AND errors
     4. If a script produces no output, check for errors or add print statements
-    
+
     IMPORTANT: Always use single quotes for the content parameter when creating files
-    
+
     Remember: Your job is to provide working, executed code examples, not just code snippets!
     """
 )
@@ -110,18 +107,18 @@ class DaytonaTools(Toolkit):
         )
 
         self.daytona = Daytona(self.config)
-
+        tools: List[Any] = [
+            self.run_code,
+            self.run_shell_command,
+            self.create_file,
+            self.read_file,
+            self.list_files,
+            self.delete_file,
+            self.change_directory,
+        ]
         super().__init__(
             name="daytona_tools",
-            tools=[
-                self.run_code,
-                self.run_shell_command,
-                self.create_file,
-                self.read_file,
-                self.list_files,
-                self.delete_file,
-                self.change_directory,
-            ],
+            tools=tools,
             instructions=self.instructions,
             add_instructions=add_instructions,
             **kwargs,

agno/tools/decorator.py

@@ -64,7 +64,6 @@ def tool(
     strict: Optional[bool] = None,
     instructions: Optional[str] = None,
     add_instructions: bool = True,
-    sanitize_arguments: Optional[bool] = None,
     show_result: Optional[bool] = None,
     stop_after_tool_call: Optional[bool] = None,
     requires_confirmation: Optional[bool] = None,
@@ -91,7 +90,6 @@ def tool(*args, **kwargs) -> Union[Function, Callable[[F], Function]]:
         name: Optional[str] - Override for the function name
         description: Optional[str] - Override for the function description
         strict: Optional[bool] - Flag for strict parameter checking
-        sanitize_arguments: Optional[bool] - If True, arguments are sanitized before passing to function (Deprecated)
         instructions: Optional[str] - Instructions for using the tool
         add_instructions: bool - If True, add instructions to the system message
         show_result: Optional[bool] - If True, shows the result after function call
@@ -131,7 +129,6 @@ def tool(*args, **kwargs) -> Union[Function, Callable[[F], Function]]:
             "strict",
             "instructions",
             "add_instructions",
-            "sanitize_arguments",
             "show_result",
             "stop_after_tool_call",
             "requires_confirmation",
@@ -248,6 +245,12 @@ def tool(*args, **kwargs) -> Union[Function, Callable[[F], Function]]:
                 and v is not None
             },
         }
+
+        # Automatically set show_result=True if stop_after_tool_call=True (unless explicitly set to False)
+        if kwargs.get("stop_after_tool_call") is True:
+            if "show_result" not in kwargs or kwargs.get("show_result") is None:
+                tool_config["show_result"] = True
+
         return Function(**tool_config)
 
     # Handle both @tool and @tool() cases

agno/tools/desi_vocal.py

@@ -8,6 +8,7 @@ from agno.agent import Agent
 from agno.media import AudioArtifact
 from agno.team.team import Team
 from agno.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import logger
 
 
@@ -16,6 +17,9 @@ class DesiVocalTools(Toolkit):
         self,
         api_key: Optional[str] = None,
         voice_id: Optional[str] = "f27d74e5-ea71-4697-be3e-f04bbd80c1a8",
+        enable_get_voices: bool = True,
+        enable_text_to_speech: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.api_key = api_key or getenv("DESI_VOCAL_API_KEY")
@@ -25,8 +29,10 @@ class DesiVocalTools(Toolkit):
         self.voice_id = voice_id
 
         tools: List[Any] = []
-        tools.append(self.get_voices)
-        tools.append(self.text_to_speech)
+        if all or enable_get_voices:
+            tools.append(self.get_voices)
+        if all or enable_text_to_speech:
+            tools.append(self.text_to_speech)
 
         super().__init__(name="desi_vocal_tools", tools=tools, **kwargs)
 
@@ -63,13 +69,13 @@ class DesiVocalTools(Toolkit):
             logger.error(f"Failed to get voices: {e}")
             return f"Error: {e}"
 
-    def text_to_speech(self, agent: Union[Agent, Team], prompt: str, voice_id: Optional[str] = None) -> str:
+    def text_to_speech(self, agent: Union[Agent, Team], prompt: str, voice_id: Optional[str] = None) -> ToolResult:
         """
         Use this function to generate audio from text.
         Args:
             prompt (str): The text to generate audio from.
         Returns:
-            result (str): The URL of the generated audio.
+            ToolResult: A ToolResult containing the generated audio or error message.
         """
         try:
             url = "https://prod-api2.desivocal.com/dv/api/v0/tts_api/generate"
@@ -91,9 +97,12 @@ class DesiVocalTools(Toolkit):
             response_json = response.json()
             audio_url = response_json["s3_path"]
 
-            agent.add_audio(AudioArtifact(id=str(uuid4()), url=audio_url))
+            audio_artifact = AudioArtifact(id=str(uuid4()), url=audio_url)
 
-            return audio_url
+            return ToolResult(
+                content=f"Audio generated successfully: {audio_url}",
+                audios=[audio_artifact],
+            )
         except Exception as e:
             logger.error(f"Failed to generate audio: {e}")
-            return f"Error: {e}"
+            return ToolResult(content=f"Error: {e}")

agno/tools/discord.py

@@ -14,10 +14,12 @@ class DiscordTools(Toolkit):
     def __init__(
         self,
         bot_token: Optional[str] = None,
-        enable_messaging: bool = True,
-        enable_history: bool = True,
-        enable_channel_management: bool = True,
-        enable_message_management: bool = True,
+        enable_send_message: bool = True,
+        enable_get_channel_messages: bool = True,
+        enable_get_channel_info: bool = True,
+        enable_list_channels: bool = True,
+        enable_delete_message: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.bot_token = bot_token or getenv("DISCORD_BOT_TOKEN")
@@ -32,14 +34,15 @@ class DiscordTools(Toolkit):
         }
 
         tools: List[Any] = []
-        if enable_messaging:
+        if enable_send_message or all:
             tools.append(self.send_message)
-        if enable_history:
+        if enable_get_channel_messages or all:
             tools.append(self.get_channel_messages)
-        if enable_channel_management:
+        if enable_get_channel_info or all:
             tools.append(self.get_channel_info)
+        if enable_list_channels or all:
             tools.append(self.list_channels)
-        if enable_message_management:
+        if enable_delete_message or all:
             tools.append(self.delete_message)
 
         super().__init__(name="discord", tools=tools, **kwargs)

agno/tools/docker.py

@@ -58,10 +58,6 @@ except ImportError:
 class DockerTools(Toolkit):
     def __init__(
         self,
-        enable_container_management: bool = True,
-        enable_image_management: bool = True,
-        enable_volume_management: bool = False,
-        enable_network_management: bool = False,
         **kwargs,
     ):
         self._check_docker_availability()
@@ -80,44 +76,36 @@ class DockerTools(Toolkit):
         except Exception as e:
             logger.error(f"Error connecting to Docker: {e}")
 
-        tools: List[Any] = []
-        if enable_container_management:
-            tools.extend(
-                [
-                    self.list_containers,
-                    self.start_container,
-                    self.stop_container,
-                    self.remove_container,
-                    self.get_container_logs,
-                    self.inspect_container,
-                    self.run_container,
-                    self.exec_in_container,
-                ]
-            )
-        if enable_image_management:
-            tools.extend(
-                [
-                    self.list_images,
-                    self.pull_image,
-                    self.remove_image,
-                    self.build_image,
-                    self.tag_image,
-                    self.inspect_image,
-                ]
-            )
-        if enable_volume_management:
-            tools.extend([self.list_volumes, self.create_volume, self.remove_volume, self.inspect_volume])
-        if enable_network_management:
-            tools.extend(
-                [
-                    self.list_networks,
-                    self.create_network,
-                    self.remove_network,
-                    self.inspect_network,
-                    self.connect_container_to_network,
-                    self.disconnect_container_from_network,
-                ]
-            )
+        tools: List[Any] = [
+            # Container management
+            self.list_containers,
+            self.start_container,
+            self.stop_container,
+            self.remove_container,
+            self.get_container_logs,
+            self.inspect_container,
+            self.run_container,
+            self.exec_in_container,
+            # Image management
+            self.list_images,
+            self.pull_image,
+            self.remove_image,
+            self.build_image,
+            self.tag_image,
+            self.inspect_image,
+            # Volume management
+            self.list_volumes,
+            self.create_volume,
+            self.remove_volume,
+            self.inspect_volume,
+            # Network management
+            self.list_networks,
+            self.create_network,
+            self.remove_network,
+            self.inspect_network,
+            self.connect_container_to_network,
+            self.disconnect_container_from_network,
+        ]
 
         super().__init__(name="docker_tools", tools=tools, **kwargs)
 

agno/tools/duckdb.py

@@ -1,3 +1,4 @@
+from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 from agno.tools import Toolkit
@@ -17,11 +18,6 @@ class DuckDbTools(Toolkit):
         init_commands: Optional[List] = None,
         read_only: bool = False,
         config: Optional[dict] = None,
-        run_queries: bool = True,
-        inspect_queries: bool = False,
-        create_tables: bool = True,
-        summarize_tables: bool = True,
-        export_tables: bool = False,
         **kwargs,
     ):
         self.db_path: Optional[str] = db_path
@@ -30,26 +26,21 @@ class DuckDbTools(Toolkit):
         self._connection: Optional[duckdb.DuckDBPyConnection] = connection
         self.init_commands: Optional[List] = init_commands
 
-        tools: List[Any] = []
-        tools.append(self.show_tables)
-        tools.append(self.describe_table)
-        if inspect_queries:
-            tools.append(self.inspect_query)
-        if run_queries:
-            tools.append(self.run_query)
-        if create_tables:
-            tools.append(self.create_table_from_path)
-        if summarize_tables:
-            tools.append(self.summarize_table)
-        if export_tables:
-            tools.append(self.export_table_to_path)
-
-        tools.append(self.load_local_path_to_table)
-        tools.append(self.load_local_csv_to_table)
-        tools.append(self.load_s3_path_to_table)
-        tools.append(self.load_s3_csv_to_table)
-        tools.append(self.create_fts_index)
-        tools.append(self.full_text_search)
+        tools: List[Any] = [
+            self.show_tables,
+            self.describe_table,
+            self.inspect_query,
+            self.run_query,
+            self.create_table_from_path,
+            self.summarize_table,
+            self.export_table_to_path,
+            self.load_local_path_to_table,
+            self.load_local_csv_to_table,
+            self.load_s3_path_to_table,
+            self.load_s3_csv_to_table,
+            self.create_fts_index,
+            self.full_text_search,
+        ]
 
         super().__init__(name="duckdb_tools", tools=tools, **kwargs)
 
@@ -177,12 +168,10 @@ class DuckDbTools(Toolkit):
         :param path: Path to get the table name from
         :return: Table name
         """
-        import os
-
         # Get the file name from the path
-        file_name = path.split("/")[-1]
+        path_obj = Path(path)
         # Get the file name without extension from the path
-        table, extension = os.path.splitext(file_name)
+        table = path_obj.stem
         # If the table isn't a valid SQL identifier, we'll need to use something else
         table = table.replace("-", "_").replace(".", "_").replace(" ", "_").replace("/", "_")
 
@@ -246,15 +235,13 @@ class DuckDbTools(Toolkit):
         :param table: Optional table name to use
         :return: Table name, SQL statement used to load the file
         """
-        import os
-
         log_debug(f"Loading {path} into duckdb")
 
         if table is None:
-            # Get the file name from the s3 path
-            file_name = path.split("/")[-1]
-            # Get the file name without extension from the s3 path
-            table, extension = os.path.splitext(file_name)
+            # Get the file name from the path
+            path_obj = Path(path)
+            # Get the file name without extension from the path
+            table = path_obj.stem
             # If the table isn't a valid SQL identifier, we'll need to use something else
             table = table.replace("-", "_").replace(".", "_").replace(" ", "_").replace("/", "_")
 
@@ -274,15 +261,13 @@ class DuckDbTools(Toolkit):
         :param delimiter: Optional delimiter to use
         :return: Table name, SQL statement used to load the file
         """
-        import os
-
         log_debug(f"Loading {path} into duckdb")
 
         if table is None:
-            # Get the file name from the s3 path
-            file_name = path.split("/")[-1]
-            # Get the file name without extension from the s3 path
-            table, extension = os.path.splitext(file_name)
+            # Get the file name from the path
+            path_obj = Path(path)
+            # Get the file name without extension from the path
+            table = path_obj.stem
             # If the table isn't a valid SQL identifier, we'll need to use something else
             table = table.replace("-", "_").replace(".", "_").replace(" ", "_").replace("/", "_")
 
@@ -305,15 +290,13 @@ class DuckDbTools(Toolkit):
         :param table: Optional table name to use
         :return: Table name, SQL statement used to load the file
         """
-        import os
-
         log_debug(f"Loading {path} into duckdb")
 
         if table is None:
-            # Get the file name from the s3 path
-            file_name = path.split("/")[-1]
-            # Get the file name without extension from the s3 path
-            table, extension = os.path.splitext(file_name)
+            # Get the file name from the path
+            path_obj = Path(path)
+            # Get the file name without extension from the path
+            table = path_obj.stem
             # If the table isn't a valid SQL identifier, we'll need to use something else
             table = table.replace("-", "_").replace(".", "_").replace(" ", "_").replace("/", "_")
 
@@ -332,15 +315,13 @@ class DuckDbTools(Toolkit):
         :param table: Optional table name to use
         :return: Table name, SQL statement used to load the file
         """
-        import os
-
         log_debug(f"Loading {path} into duckdb")
 
         if table is None:
-            # Get the file name from the s3 path
-            file_name = path.split("/")[-1]
-            # Get the file name without extension from the s3 path
-            table, extension = os.path.splitext(file_name)
+            # Get the file name from the path
+            path_obj = Path(path)
+            # Get the file name without extension from the path
+            table = path_obj.stem
             # If the table isn't a valid SQL identifier, we'll need to use something else
             table = table.replace("-", "_").replace(".", "_").replace(" ", "_").replace("/", "_")