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

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("/", "_")
 

agno/tools/duckduckgo.py

@@ -7,7 +7,7 @@ from agno.utils.log import log_debug
 try:
     from ddgs import DDGS
 except ImportError:
-    raise ImportError("`duckduckgo-search` not installed. Please install using `pip install ddgs`")
+    raise ImportError("`ddgs` not installed. Please install using `pip install ddgs`")
 
 
 class DuckDuckGoTools(Toolkit):
@@ -25,8 +25,9 @@ class DuckDuckGoTools(Toolkit):
 
     def __init__(
         self,
-        search: bool = True,
-        news: bool = True,
+        enable_search: bool = True,
+        enable_news: bool = True,
+        all: bool = False,
         modifier: Optional[str] = None,
         fixed_max_results: Optional[int] = None,
         proxy: Optional[str] = None,
@@ -41,9 +42,9 @@ class DuckDuckGoTools(Toolkit):
         self.verify_ssl: bool = verify_ssl
 
         tools: List[Any] = []
-        if search:
+        if all or enable_search:
             tools.append(self.duckduckgo_search)
-        if news:
+        if all or enable_news:
             tools.append(self.duckduckgo_news)
 
         super().__init__(name="duckduckgo", tools=tools, **kwargs)
@@ -63,7 +64,7 @@ class DuckDuckGoTools(Toolkit):
 
         log_debug(f"Searching DDG for: {search_query}")
         with DDGS(proxy=self.proxy, timeout=self.timeout, verify=self.verify_ssl) as ddgs:
-            results = ddgs.text(search_query, max_results=actual_max_results)
+            results = ddgs.text(query=search_query, max_results=actual_max_results)
 
         return json.dumps(results, indent=2)
 
@@ -81,6 +82,6 @@ class DuckDuckGoTools(Toolkit):
 
         log_debug(f"Searching DDG news for: {query}")
         with DDGS(proxy=self.proxy, timeout=self.timeout, verify=self.verify_ssl) as ddgs:
-            results = ddgs.news(query, max_results=actual_max_results)
+            results = ddgs.news(query=query, max_results=actual_max_results)
 
         return json.dumps(results, indent=2)

agno/tools/e2b.py

@@ -11,6 +11,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.code_execution import prepare_python_code
 from agno.utils.log import logger
 
@@ -24,27 +25,14 @@ class E2BTools(Toolkit):
     def __init__(
         self,
         api_key: Optional[str] = None,
-        run_code: bool = True,
-        upload_file: bool = True,
-        download_result: bool = True,
-        filesystem: bool = False,
-        internet_access: bool = False,
-        sandbox_management: bool = False,
         timeout: int = 300,  # 5 minutes default timeout
         sandbox_options: Optional[Dict[str, Any]] = None,
-        command_execution: bool = False,
         **kwargs,
     ):
         """Initialize E2B toolkit for code interpretation and running Python code in a sandbox.
 
         Args:
             api_key: E2B API key (defaults to E2B_API_KEY environment variable)
-            run_code: Whether to register the run_code function
-            upload_file: Whether to register the upload_file function
-            download_result: Whether to register the download_result function
-            filesystem: Whether to register filesystem operations
-            internet_access: Whether to register internet access functions
-            sandbox_management: Whether to register sandbox management functions
             timeout: Timeout in seconds for the sandbox (default: 5 minutes)
             sandbox_options: Additional options to pass to the Sandbox constructor
         """
@@ -58,7 +46,7 @@ class E2BTools(Toolkit):
 
         # According to official docs, the parameter is 'timeout' (in seconds), not 'timeout_ms'
         try:
-            self.sandbox = Sandbox(api_key=self.api_key, timeout=timeout, **self.sandbox_options)
+            self.sandbox = Sandbox.create(api_key=self.api_key, timeout=timeout, **self.sandbox_options)
         except Exception as e:
             logger.error(f"Warning: Could not create sandbox: {e}")
             raise e
@@ -67,26 +55,33 @@ class E2BTools(Toolkit):
         self.last_execution = None
         self.downloaded_files: Dict[int, str] = {}
 
-        tools: List[Any] = []
-
-        if run_code:
-            tools.append(self.run_python_code)
-        if upload_file:
-            tools.append(self.upload_file)
-        if download_result:
-            tools.extend([self.download_png_result, self.download_chart_data, self.download_file_from_sandbox])
-        if filesystem:
-            tools.extend([self.list_files, self.read_file_content, self.write_file_content, self.watch_directory])
-        if internet_access:
-            tools.extend([self.get_public_url, self.run_server])
-        if sandbox_management:
-            tools.extend(
-                [self.set_sandbox_timeout, self.get_sandbox_status, self.shutdown_sandbox, self.list_running_sandboxes]
-            )
-        if command_execution:
-            tools.extend(
-                [self.run_command, self.stream_command, self.run_background_command, self.kill_background_command]
-            )
+        tools: List[Any] = [
+            # Code execution
+            self.run_python_code,
+            # File operations
+            self.upload_file,
+            self.download_png_result,
+            self.download_chart_data,
+            self.download_file_from_sandbox,
+            # Filesystem operations
+            self.list_files,
+            self.read_file_content,
+            self.write_file_content,
+            self.watch_directory,
+            # Internet access
+            self.get_public_url,
+            self.run_server,
+            # Sandbox management
+            self.set_sandbox_timeout,
+            self.get_sandbox_status,
+            self.shutdown_sandbox,
+            self.list_running_sandboxes,
+            # Command execution
+            self.run_command,
+            self.stream_command,
+            self.run_background_command,
+            self.kill_background_command,
+        ]
 
         super().__init__(name="e2b_tools", tools=tools, **kwargs)
 
@@ -164,9 +159,9 @@ class E2BTools(Toolkit):
 
     def download_png_result(
         self, agent: Union[Agent, Team], result_index: int = 0, output_path: Optional[str] = None
-    ) -> str:
+    ) -> ToolResult:
         """
-        Add a PNG image result from the last code execution as an ImageArtifact to the agent.
+        Add a PNG image result from the last code execution as an ImageArtifact.
 
         Args:
             agent: The agent to add the image artifact to
@@ -174,21 +169,23 @@ class E2BTools(Toolkit):
             output_path (str, optional): Optional path to also save the PNG file. If not provided, image is only added as artifact.
 
         Returns:
-            str: Success message or error message
+            ToolResult: Contains the PNG image or error message.
         """
         if not self.last_execution:
-            return "No code has been executed yet"
+            return ToolResult(content="No code has been executed yet")
 
         try:
             # Check if the result exists
             if result_index >= len(self.last_execution.results):
-                return f"Result index {result_index} is out of range. Only {len(self.last_execution.results)} results available."
+                return ToolResult(
+                    content=f"Result index {result_index} is out of range. Only {len(self.last_execution.results)} results available."
+                )
 
             result = self.last_execution.results[result_index]
 
             # Check if the result has a PNG
             if not result.png:
-                return f"Result at index {result_index} is not a PNG image"
+                return ToolResult(content=f"Result at index {result_index} is not a PNG image")
 
             # Decode PNG data from base64
             png_data = base64.b64decode(result.png)
@@ -200,7 +197,6 @@ class E2BTools(Toolkit):
                 self.downloaded_files[result_index] = output_path
 
             # Create a temporary file to store the image for URL access
-
             # Create a temp file with .png extension
             fd, temp_path = tempfile.mkstemp(suffix=".png")
             with fdopen(fd, "wb") as tmp:
@@ -209,28 +205,28 @@ class E2BTools(Toolkit):
             # Generate a file:// URL for the temp file
             file_url = f"file://{temp_path}"
 
-            # Add image artifact to the agent
+            # Create ImageArtifact
             image_id = str(uuid4())
-            agent.add_image(
-                ImageArtifact(
-                    id=image_id, url=file_url, original_prompt=f"Generated from code execution result {result_index}"
-                )
+            image_artifact = ImageArtifact(
+                id=image_id, url=file_url, original_prompt=f"Generated from code execution result {result_index}"
             )
 
             if output_path:
-                return f"Image added as artifact with ID {image_id} and saved to {output_path}"
+                content_msg = f"Image added as artifact with ID {image_id} and saved to {output_path}"
             else:
-                return f"Image added as artifact with ID {image_id}"
+                content_msg = f"Image added as artifact with ID {image_id}"
+
+            return ToolResult(content=content_msg, images=[image_artifact])
 
         except Exception as e:
-            return json.dumps({"status": "error", "message": f"Error processing PNG: {str(e)}"})
+            return ToolResult(content=f"Error processing PNG: {str(e)}")
 
     def download_chart_data(
         self, agent: Agent, result_index: int = 0, output_path: Optional[str] = None, add_as_artifact: bool = True
-    ) -> str:
+    ) -> ToolResult:
         """
         Extract chart data from an interactive chart in the execution results.
-        Optionally add the chart as an image artifact to the agent.
+        Optionally add the chart as an image artifact.
 
         Args:
             agent: The agent to add the chart artifact to
@@ -239,21 +235,23 @@ class E2BTools(Toolkit):
             add_as_artifact (bool): Whether to add the chart as an image artifact (default: True)
 
         Returns:
-            str: Information about the extracted chart data or error message
+            ToolResult: Contains chart information and optionally the chart image.
         """
         if not self.last_execution:
-            return "No code has been executed yet"
+            return ToolResult(content="No code has been executed yet")
 
         try:
             # Check if the result exists
             if result_index >= len(self.last_execution.results):
-                return f"Result index {result_index} is out of range. Only {len(self.last_execution.results)} results available."
+                return ToolResult(
+                    content=f"Result index {result_index} is out of range. Only {len(self.last_execution.results)} results available."
+                )
 
             result = self.last_execution.results[result_index]
 
             # Check if the result has chart data
             if not result.chart:
-                return f"Result at index {result_index} does not contain interactive chart data"
+                return ToolResult(content=f"Result at index {result_index} does not contain interactive chart data")
 
             # Format chart data
             chart_data = result.chart
@@ -276,6 +274,7 @@ class E2BTools(Toolkit):
             if "y_label" in chart_data:
                 summary += f"Y-axis: {chart_data['y_label']}\n"
 
+            image_artifact = None
             # Add as an image artifact if requested
             if add_as_artifact and result.png:
                 # Decode PNG data from base64
@@ -293,20 +292,21 @@ class E2BTools(Toolkit):
                 # Generate a file:// URL for the temp file
                 file_url = f"file://{temp_path}"
 
-                # Add image artifact to the agent
+                # Create ImageArtifact
                 image_id = str(uuid4())
-                agent.add_image(
-                    ImageArtifact(
-                        id=image_id, url=file_url, original_prompt=f"Interactive {chart_type} chart from code execution"
-                    )
+                image_artifact = ImageArtifact(
+                    id=image_id, url=file_url, original_prompt=f"Interactive {chart_type} chart from code execution"
                 )
 
                 summary += f"\nChart image added as artifact with ID {image_id}"
 
-            return summary
+            if image_artifact:
+                return ToolResult(content=summary, images=[image_artifact])
+            else:
+                return ToolResult(content=summary)
 
         except Exception as e:
-            return json.dumps({"status": "error", "message": f"Error extracting chart data: {str(e)}"})
+            return ToolResult(content=f"Error extracting chart data: {str(e)}")
 
     def download_file_from_sandbox(self, sandbox_path: str, local_path: Optional[str] = None) -> str:
         """

agno/tools/eleven_labs.py

@@ -9,6 +9,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
 
 try:
@@ -39,6 +40,10 @@ class ElevenLabsTools(Toolkit):
         target_directory: Optional[str] = None,
         model_id: str = "eleven_multilingual_v2",
         output_format: ElevenLabsAudioOutputFormat = "mp3_44100_64",
+        enable_get_voices: bool = True,
+        enable_generate_sound_effect: bool = True,
+        enable_text_to_speech: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.api_key = api_key or getenv("ELEVEN_LABS_API_KEY")
@@ -57,10 +62,12 @@ class ElevenLabsTools(Toolkit):
         self.eleven_labs_client = ElevenLabs(api_key=self.api_key)
 
         tools: List[Any] = []
-
-        tools.append(self.get_voices)
-        tools.append(self.generate_sound_effect)
-        tools.append(self.text_to_speech)
+        if all or enable_get_voices:
+            tools.append(self.get_voices)
+        if all or enable_generate_sound_effect:
+            tools.append(self.generate_sound_effect)
+        if all or enable_text_to_speech:
+            tools.append(self.text_to_speech)
 
         super().__init__(name="elevenlabs_tools", tools=tools, **kwargs)
 
@@ -122,9 +129,7 @@ class ElevenLabsTools(Toolkit):
 
         return base64_audio
 
-    def generate_sound_effect(
-        self, agent: Union[Agent, Team], prompt: str, duration_seconds: Optional[float] = None
-    ) -> str:
+    def generate_sound_effect(self, prompt: str, duration_seconds: Optional[float] = None) -> ToolResult:
         """
         Use this function to generate sound effect audio from a text prompt.
 
@@ -132,7 +137,7 @@ class ElevenLabsTools(Toolkit):
             prompt (str): Text to generate audio from.
             duration_seconds (Optional[float]): Duration in seconds to generate audio from. Has to be between 0.5 and 22.
         Returns:
-            str: Return the path to the generated audio file.
+            ToolResult: A ToolResult containing the generated audio or error message.
         """
         try:
             audio_generator = self.eleven_labs_client.text_to_sound_effects.convert(
@@ -141,29 +146,30 @@ class ElevenLabsTools(Toolkit):
 
             base64_audio = self._process_audio(audio_generator)
 
-            # Attach to the agent
-            agent.add_audio(
-                AudioArtifact(
-                    id=str(uuid4()),
-                    base64_audio=base64_audio,
-                    mime_type="audio/mpeg",
-                )
+            # Create AudioArtifact
+            audio_artifact = AudioArtifact(
+                id=str(uuid4()),
+                base64_audio=base64_audio,
+                mime_type="audio/mpeg",
             )
 
-            return "Audio generated successfully"
+            return ToolResult(
+                content="Audio generated successfully",
+                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}")
 
-    def text_to_speech(self, agent: Union[Agent, Team], prompt: str) -> str:
+    def text_to_speech(self, agent: Union[Agent, Team], prompt: str) -> ToolResult:
         """
         Use this function to convert text to speech audio.
 
         Args:
             prompt (str): Text to generate audio from.
         Returns:
-            str: Return the path to the generated audio file.
+            ToolResult: A ToolResult containing the generated audio or error message.
         """
         try:
             audio_generator = self.eleven_labs_client.text_to_speech.convert(
@@ -175,17 +181,18 @@ class ElevenLabsTools(Toolkit):
 
             base64_audio = self._process_audio(audio_generator)
 
-            # Attach to the agent
-            agent.add_audio(
-                AudioArtifact(
-                    id=str(uuid4()),
-                    base64_audio=base64_audio,
-                    mime_type="audio/mpeg",
-                )
+            # Create AudioArtifact
+            audio_artifact = AudioArtifact(
+                id=str(uuid4()),
+                base64_audio=base64_audio,
+                mime_type="audio/mpeg",
             )
 
-            return "Audio generated successfully"
+            return ToolResult(
+                content="Audio generated successfully",
+                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/email.py

@@ -11,6 +11,8 @@ class EmailTools(Toolkit):
         sender_name: Optional[str] = None,
         sender_email: Optional[str] = None,
         sender_passkey: Optional[str] = None,
+        enable_email_user: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.receiver_email: Optional[str] = receiver_email
@@ -19,7 +21,8 @@ class EmailTools(Toolkit):
         self.sender_passkey: Optional[str] = sender_passkey
 
         tools = []
-        tools.append(self.email_user)
+        if all or enable_email_user:
+            tools.append(self.email_user)
 
         # Call superclass with tools list
         super().__init__(name="email_tools", tools=tools, **kwargs)

agno/tools/evm.py

@@ -21,6 +21,8 @@ class EvmTools(Toolkit):
         self,
         private_key: Optional[str] = None,
         rpc_url: Optional[str] = None,
+        enable_send_transaction: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         """Initialize EVM tools for blockchain interactions.
@@ -50,7 +52,11 @@ class EvmTools(Toolkit):
         self.account: "LocalAccount" = self.web3_client.eth.account.from_key(self.private_key)
         log_debug(f"Your wallet address is: {self.account.address}")
 
-        super().__init__(name="evm_tools", tools=[self.send_transaction], **kwargs)
+        tools = []
+        if all or enable_send_transaction:
+            tools.append(self.send_transaction)
+
+        super().__init__(name="evm_tools", tools=tools, **kwargs)
 
     def get_max_priority_fee_per_gas(self) -> int:
         """Get the max priority fee per gas for the transaction.