agno 1.8.0__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

@@ -2,6 +2,8 @@ import json
 from os import getenv
 from typing import Any, List, Optional
 
+import requests
+
 from agno.tools import Toolkit
 from agno.utils.log import log_info, logger
 
@@ -37,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")
@@ -55,21 +56,30 @@ class ConfluenceTools(Toolkit):
         if not self.password:
             raise ValueError("Confluence API KEY or password not provided")
 
-        self.confluence = Confluence(
-            url=self.url, username=self.username, password=self.password, verify_ssl=verify_ssl
-        )
+        session = requests.Session()
+        session.verify = verify_ssl
+
         if not verify_ssl:
             import urllib3
 
             urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
 
-        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)
+        self.confluence = Confluence(
+            url=self.url,
+            username=self.username,
+            password=self.password,
+            verify_ssl=verify_ssl,
+            session=session,
+        )
+
+        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)
 
@@ -87,6 +97,9 @@ class ConfluenceTools(Toolkit):
         try:
             log_info(f"Retrieving page content from space '{space_name}'")
             key = self.get_space_key(space_name=space_name)
+            if key == "No space found":
+                return json.dumps({"error": f"Space '{space_name}' not found"})
+
             page = self.confluence.get_page_by_title(key, page_title, expand=expand)
             if page:
                 log_info(f"Successfully retrieved page '{page_title}' from space '{space_name}'")
@@ -106,7 +119,20 @@ class ConfluenceTools(Toolkit):
             str: List of space details as a string.
         """
         log_info("Retrieving details for all Confluence spaces")
-        results = self.confluence.get_all_spaces()["results"]
+        results = []
+        start = 0
+        limit = 50
+
+        while True:
+            spaces_data = self.confluence.get_all_spaces(start=start, limit=limit)
+            if not spaces_data.get("results"):
+                break
+            results.extend(spaces_data["results"])
+
+            if len(spaces_data["results"]) < limit:
+                break
+            start += limit
+
         return str(results)
 
     def get_space_key(self, space_name: str):
@@ -118,13 +144,29 @@ class ConfluenceTools(Toolkit):
         Returns:
             str: Space key or "No space found" if space doesn't exist.
         """
-        result = self.confluence.get_all_spaces()
-        spaces = result["results"]
+        start = 0
+        limit = 50
+
+        while True:
+            result = self.confluence.get_all_spaces(start=start, limit=limit)
+            if not result.get("results"):
+                break
+
+            spaces = result["results"]
+
+            for space in spaces:
+                if space["name"].lower() == space_name.lower():
+                    log_info(f"Found space key for '{space_name}': {space['key']}")
+                    return space["key"]
+
+            for space in spaces:
+                if space["key"] == space_name:
+                    log_info(f"'{space_name}' is already a space key")
+                    return space_name
 
-        for space in spaces:
-            if space["name"] == space_name:
-                log_info(f"Found space key for '{space_name}'")
-                return space["key"]
+            if len(spaces) < limit:
+                break
+            start += limit
 
         logger.warning(f"No space named {space_name} found")
         return "No space found"
@@ -140,9 +182,17 @@ class ConfluenceTools(Toolkit):
         """
         log_info(f"Retrieving all pages from space '{space_name}'")
         space_key = self.get_space_key(space_name)
+
+        if space_key == "No space found":
+            return json.dumps({"error": f"Space '{space_name}' not found"})
+
         page_details = self.confluence.get_all_pages_from_space(
             space_key, status=None, expand=None, content_type="page"
         )
+
+        if not page_details:
+            return json.dumps({"error": f"No pages found in space '{space_name}'"})
+
         page_details = str([{"id": page["id"], "title": page["title"]} for page in page_details])
         return page_details
 
@@ -160,6 +210,9 @@ class ConfluenceTools(Toolkit):
         """
         try:
             space_key = self.get_space_key(space_name=space_name)
+            if space_key == "No space found":
+                return json.dumps({"error": f"Space '{space_name}' not found"})
+
             page = self.confluence.create_page(space_key, title, body, parent_id=parent_id)
             log_info(f"Page created: {title} with ID {page['id']}")
             return json.dumps({"id": page["id"], "title": title})

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)