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

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
         """
@@ -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.

agno/tools/exa.py

@@ -19,11 +19,15 @@ class ExaTools(Toolkit):
     functionalities to perform categorized searches and retrieve structured results.
 
     Args:
+        enable_search (bool): Enable search functionality. Default is True.
+        enable_get_contents (bool): Enable get contents functionality. Default is True.
+        enable_find_similar (bool): Enable find similar functionality. Default is True.
+        enable_answer (bool): Enable answer generation. Default is True.
+        enable_research (bool): Enable research tool functionality. Default is False.
+        all (bool): Enable all tools. Overrides individual flags when True. Default is False.
         text (bool): Retrieve text content from results. Default is True.
         text_length_limit (int): Max length of text content per result. Default is 1000.
         highlights (bool): Include highlighted snippets. Default is True.
-        answer (bool): Enable answer generation. Default is True.
-        research (bool): Enable research tool functionality. Default is True.
         api_key (Optional[str]): Exa API key. Retrieved from `EXA_API_KEY` env variable if not provided.
         num_results (Optional[int]): Default number of search results. Overrides individual searches if set.
         start_crawl_date (Optional[str]): Include results crawled on/after this date (`YYYY-MM-DD`).
@@ -42,11 +46,12 @@ class ExaTools(Toolkit):
 
     def __init__(
         self,
-        search: bool = True,
-        get_contents: bool = True,
-        find_similar: bool = True,
-        answer: bool = True,
-        research: bool = False,
+        enable_search: bool = True,
+        enable_get_contents: bool = True,
+        enable_find_similar: bool = True,
+        enable_answer: bool = True,
+        enable_research: bool = False,
+        all: bool = False,
         text: bool = True,
         text_length_limit: int = 1000,
         highlights: bool = True,
@@ -96,15 +101,15 @@ class ExaTools(Toolkit):
         self.research_model: Literal["exa-research", "exa-research-pro"] = research_model
 
         tools: List[Any] = []
-        if search:
+        if all or enable_search:
             tools.append(self.search_exa)
-        if get_contents:
+        if all or enable_get_contents:
             tools.append(self.get_contents)
-        if find_similar:
+        if all or enable_find_similar:
             tools.append(self.find_similar)
-        if answer:
+        if all or enable_answer:
             tools.append(self.exa_answer)
-        if research:
+        if all or enable_research:
             tools.append(self.research)
 
         super().__init__(name="exa", tools=tools, **kwargs)
@@ -353,14 +358,14 @@ class ExaTools(Toolkit):
             else:
                 task_kwargs["output_infer_schema"] = True
 
-            task_result = self._execute_with_timeout(self.exa.research.create_task, **task_kwargs)
+            task_result = self._execute_with_timeout(self.exa.research.create_task, **task_kwargs)  # type: ignore
             task_id = task_result.id
 
             if self.show_results:
                 log_info(f"Research task created with ID: {task_id}")
 
             # Step 2: Poll until complete (using default polling settings)
-            task = self.exa.research.poll_task(task_id)
+            task = self.exa.research.poll_task(task_id)  # type: ignore
 
             # Step 3: Format and return results
             result: Dict[str, Any] = {"data": task.data, "citations": {}}

agno/tools/fal.py

@@ -10,6 +10,7 @@ from agno.agent import Agent
 from agno.media import ImageArtifact, VideoArtifact
 from agno.team.team import Team
 from agno.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import log_info, logger
 
 try:
@@ -23,16 +24,22 @@ class FalTools(Toolkit):
         self,
         api_key: Optional[str] = None,
         model: str = "fal-ai/hunyuan-video",
+        enable_generate_media: bool = True,
+        enable_image_to_image: bool = False,
+        all: bool = False,
         **kwargs,
     ):
-        self.api_key = api_key or getenv("FAL_KEY")
+        self.api_key = api_key or getenv("FAL_API_KEY")
         if not self.api_key:
-            logger.error("FAL_KEY not set. Please set the FAL_KEY environment variable.")
+            logger.error("FAL_API_KEY not set. Please set the FAL_API_KEY environment variable.")
         self.model = model
         self.seen_logs: set[str] = set()
 
         tools = []
-        tools.append(self.generate_media)
+        if all or enable_generate_media:
+            tools.append(self.generate_media)
+        if all or enable_image_to_image:
+            tools.append(self.image_to_image)
 
         super().__init__(name="fal-tools", tools=tools, **kwargs)
 
@@ -44,14 +51,14 @@ class FalTools(Toolkit):
                     log_info(message)
                     self.seen_logs.add(message)
 
-    def generate_media(self, agent: Union[Agent, Team], prompt: str) -> str:
+    def generate_media(self, agent: Union[Agent, Team], prompt: str) -> ToolResult:
         """
         Use this function to run a model with a given prompt.
 
         Args:
             prompt (str): A text description of the task.
         Returns:
-            str: Return the result of the model.
+            ToolResult: Contains the generated media and success message.
         """
         try:
             result = fal_client.subscribe(
@@ -65,32 +72,27 @@ class FalTools(Toolkit):
 
             if "image" in result:
                 url = result.get("image", {}).get("url", "")
-                agent.add_image(
-                    ImageArtifact(
-                        id=media_id,
-                        url=url,
-                    )
+                image_artifact = ImageArtifact(
+                    id=media_id,
+                    url=url,
                 )
-                media_type = "image"
+                return ToolResult(content=f"Image generated successfully at {url}", images=[image_artifact])
             elif "video" in result:
                 url = result.get("video", {}).get("url", "")
-                agent.add_video(
-                    VideoArtifact(
-                        id=media_id,
-                        url=url,
-                    )
+                video_artifact = VideoArtifact(
+                    id=media_id,
+                    url=url,
                 )
-                media_type = "video"
+                return ToolResult(content=f"Video generated successfully at {url}", videos=[video_artifact])
             else:
                 logger.error(f"Unsupported type in result: {result}")
-                return f"Unsupported type in result: {result}"
+                return ToolResult(content=f"Unsupported type in result: {result}")
 
-            return f"{media_type.capitalize()} generated successfully at {url}"
         except Exception as e:
             logger.error(f"Failed to run model: {e}")
-            return f"Error: {e}"
+            return ToolResult(content=f"Error: {e}")
 
-    def image_to_image(self, agent: Union[Agent, Team], prompt: str, image_url: Optional[str] = None) -> str:
+    def image_to_image(self, agent: Union[Agent, Team], prompt: str, image_url: Optional[str] = None) -> ToolResult:
         """
         Use this function to transform an input image based on a text prompt using the Fal AI image-to-image model.
         The model takes an existing image and generates a new version modified according to your prompt.
@@ -101,7 +103,7 @@ class FalTools(Toolkit):
             image_url (str): The URL of the image to use for the generation.
 
         Returns:
-            str: Return the result of the model.
+            ToolResult: Contains the generated image and success message.
         """
 
         try:
@@ -113,15 +115,13 @@ class FalTools(Toolkit):
             )
             url = result.get("images", [{}])[0].get("url", "")
             media_id = str(uuid4())
-            agent.add_image(
-                ImageArtifact(
-                    id=media_id,
-                    url=url,
-                )
+            image_artifact = ImageArtifact(
+                id=media_id,
+                url=url,
             )
 
-            return f"Image generated successfully at {url}"
+            return ToolResult(content=f"Image generated successfully at {url}", images=[image_artifact])
 
         except Exception as e:
             logger.error(f"Failed to generate image: {e}")
-            return f"Error: {e}"
+            return ToolResult(content=f"Error: {e}")