agno 1.8.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

agno/tools/cartesia.py

@@ -1,13 +1,13 @@
 import json
-from base64 import b64encode
 from os import getenv
 from typing import Any, Dict, List, Optional, Union
 from uuid import uuid4
 
 from agno.agent import Agent
-from agno.media import AudioArtifact
+from agno.media import Audio
 from agno.team.team import Team
 from agno.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import log_debug, log_error, log_info
 
 try:
@@ -22,9 +22,10 @@ class CartesiaTools(Toolkit):
         api_key: Optional[str] = None,
         model_id: str = "sonic-2",
         default_voice_id: str = "78ab82d5-25be-4f7d-82b3-7ad64e5b85b2",
-        text_to_speech_enabled: bool = True,
-        list_voices_enabled: bool = True,
-        voice_localize_enabled: bool = False,
+        enable_text_to_speech: bool = True,
+        enable_list_voices: bool = True,
+        enable_localize_voice: bool = False,
+        all: bool = False,
         **kwargs,
     ):
         self.api_key = api_key or getenv("CARTESIA_API_KEY")
@@ -37,11 +38,11 @@ class CartesiaTools(Toolkit):
         self.default_voice_id = default_voice_id
 
         tools: List[Any] = []
-        if voice_localize_enabled:
+        if all or enable_localize_voice:
             tools.append(self.localize_voice)
-        if text_to_speech_enabled:
+        if all or enable_text_to_speech:
             tools.append(self.text_to_speech)
-        if list_voices_enabled:
+        if all or enable_list_voices:
             tools.append(self.list_voices)
 
         super().__init__(name="cartesia_tools", tools=tools, **kwargs)
@@ -131,15 +132,15 @@ class CartesiaTools(Toolkit):
         agent: Union[Agent, Team],
         transcript: str,
         voice_id: Optional[str] = None,
-    ) -> str:
+    ) -> ToolResult:
         """
-        Convert text to speechß.
+        Convert text to speech.
         Args:
             transcript: The text to convert to speech
             voice_id (optional): The ID of the voice to use for the text-to-speech. If None, uses the default voice ID configured in the tool. Defaults to None.
 
         Returns:
-            str: Success or error message.
+            ToolResult: A ToolResult containing the generated audio or error message.
         """
 
         try:
@@ -168,17 +169,19 @@ class CartesiaTools(Toolkit):
 
             audio_iterator = self.client.tts.bytes(**params)
             audio_data = b"".join(chunk for chunk in audio_iterator)
-            base64_audio = b64encode(audio_data).decode("utf-8")
 
-            artifact = AudioArtifact(
+            # Create AudioArtifact
+            audio_artifact = Audio(
                 id=str(uuid4()),
-                base64_audio=base64_audio,
+                content=audio_data,
                 mime_type=mime_type,  # Hardcoded to audio/mpeg
             )
-            agent.add_audio(artifact)
 
-            return "Audio generated and attached successfully."
+            return ToolResult(
+                content="Audio generated and attached successfully.",
+                audios=[audio_artifact],
+            )
 
         except Exception as e:
             log_error(f"Error generating speech with Cartesia: {e}", exc_info=True)
-            return f"Error generating speech: {e}"
+            return ToolResult(content=f"Error generating speech: {e}")

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

@@ -3,9 +3,10 @@ from typing import Any, List, Literal, Optional, Union
 from uuid import uuid4
 
 from agno.agent import Agent
-from agno.media import ImageArtifact
+from agno.media import Image
 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,24 @@ 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 = Image(
+                            id=str(uuid4()),
+                            url=img.url,
+                            original_prompt=prompt,
+                            revised_prompt=img.revised_prompt,
                         )
+                        generated_images.append(image)
                         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

@@ -5,9 +5,10 @@ from uuid import uuid4
 import requests
 
 from agno.agent import Agent
-from agno.media import AudioArtifact
+from agno.media import Audio
 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 = Audio(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)