agno 0.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/tools/eleven_labs.py

@@ -1,14 +1,15 @@
-from base64 import b64encode
 from io import BytesIO
 from os import getenv, path
 from pathlib import Path
-from typing import Iterator, Literal, Optional
+from typing import Any, Iterator, List, Literal, 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.utils.log import logger
+from agno.tools.function import ToolResult
+from agno.utils.log import log_error, log_info
 
 try:
     from elevenlabs import ElevenLabs  # type: ignore
@@ -38,12 +39,15 @@ 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,
     ):
-        super().__init__(name="elevenlabs_tools")
-
         self.api_key = api_key or getenv("ELEVEN_LABS_API_KEY")
         if not self.api_key:
-            logger.error("ELEVEN_LABS_API_KEY not set. Please set the ELEVEN_LABS_API_KEY environment variable.")
+            log_error("ELEVEN_LABS_API_KEY not set. Please set the ELEVEN_LABS_API_KEY environment variable.")
 
         self.target_directory = target_directory
         self.voice_id = voice_id
@@ -55,13 +59,20 @@ class ElevenLabsTools(Toolkit):
             target_path.mkdir(parents=True, exist_ok=True)
 
         self.eleven_labs_client = ElevenLabs(api_key=self.api_key)
-        self.register(self.get_voices)
-        self.register(self.generate_sound_effect)
-        self.register(self.text_to_speech)
+
+        tools: List[Any] = []
+        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)
 
     def get_voices(self) -> str:
         """
-        Use this function to get all the voices available.
+        Get all the voices available.
 
         Returns:
             result (list): A list of voices that have an ID, name and description.
@@ -82,20 +93,19 @@ class ElevenLabsTools(Toolkit):
             return str(response)
 
         except Exception as e:
-            logger.error(f"Failed to fetch voices: {e}")
+            log_error(f"Failed to fetch voices: {e}")
             return f"Error: {e}"
 
-    def _process_audio(self, audio_generator: Iterator[bytes]) -> str:
-        # Step 1: Write audio data to BytesIO
+    def _process_audio(self, audio_generator: Iterator[bytes]) -> bytes:
         audio_bytes = BytesIO()
         for chunk in audio_generator:
             audio_bytes.write(chunk)
-        audio_bytes.seek(0)  # Rewind the stream
 
-        # Step 2: Encode as Base64
-        base64_audio = b64encode(audio_bytes.read()).decode("utf-8")
+        # Read bytes
+        audio_bytes.seek(0)
+        audio_data = audio_bytes.read()
 
-        # Step 3: Optionally save to disk if target_directory exists
+        # Save to disk if target_directory exists
         if self.target_directory:
             # Determine file extension based on output format
             if self.output_format.startswith("mp3"):
@@ -110,76 +120,77 @@ class ElevenLabsTools(Toolkit):
             output_filename = f"{uuid4()}.{extension}"
             output_path = path.join(self.target_directory, output_filename)
 
-            # Write from BytesIO to disk
-            audio_bytes.seek(0)  # Reset the BytesIO stream again
             with open(output_path, "wb") as f:
-                f.write(audio_bytes.read())
+                f.write(audio_data)
 
-        return base64_audio
+            log_info(f"Audio saved to: {output_path}")
 
-    def generate_sound_effect(self, agent: Agent, prompt: str, duration_seconds: Optional[float] = None) -> str:
+        return audio_data
+
+    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.
+        Generate a sound effect from a text description.
 
         Args:
-            prompt (str): Text to generate audio from.
-            duration_seconds (Optional[float]): Duration in seconds to generate audio from.
+            prompt (str): Description of the sound effect
+            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(
                 text=prompt, duration_seconds=duration_seconds
             )
 
-            base64_audio = self._process_audio(audio_generator)
+            audio_data = 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 = Audio(
+                id=str(uuid4()),
+                content=audio_data,
+                mime_type="audio/mpeg",
             )
 
-            return "Audio generated successfully"
+            return ToolResult(
+                content="Sound effect generated successfully",
+                audios=[audio_artifact],
+            )
 
         except Exception as e:
-            logger.error(f"Failed to generate audio: {e}")
-            return f"Error: {e}"
+            log_error(f"Failed to generate sound effect: {e}")
+            return ToolResult(content=f"Error: {e}")
 
-    def text_to_speech(self, agent: Agent, prompt: str, voice_id: Optional[str] = None) -> str:
+    def text_to_speech(self, agent: Union[Agent, Team], prompt: str) -> ToolResult:
         """
-        Use this function to convert text to speech audio.
+        Convert text to speech.
 
         Args:
             prompt (str): Text to generate audio from.
-            voice_id (Optional[str]): The ID of the voice to use for audio generation. Uses default if none is specified.
         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(
                 text=prompt,
-                voice_id=voice_id or self.voice_id,
+                voice_id=self.voice_id,
                 model_id=self.model_id,
                 output_format=self.output_format,
             )
 
-            base64_audio = self._process_audio(audio_generator)
+            audio_data = 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 = Audio(
+                id=str(uuid4()),
+                content=audio_data,
+                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}"
+            log_error(f"Failed to generate audio: {e}")
+            return ToolResult(content=f"Error: {e}")

agno/tools/email.py

@@ -1,7 +1,7 @@
 from typing import Optional
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_info, logger
 
 
 class EmailTools(Toolkit):
@@ -11,15 +11,23 @@ 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,
     ):
-        super().__init__(name="email_tools")
         self.receiver_email: Optional[str] = receiver_email
         self.sender_name: Optional[str] = sender_name
         self.sender_email: Optional[str] = sender_email
         self.sender_passkey: Optional[str] = sender_passkey
-        self.register(self.email_user)
 
-    def email_user(self, subject: str, body: str) -> str:
+        tools = []
+        if all or enable_email_user:
+            tools.append(self.email_user)
+
+        # Call superclass with tools list
+        super().__init__(name="email_tools", tools=tools, **kwargs)
+
+    def email_user(self, subject: str, body: str, **kwargs) -> str:
         """Emails the user with the given subject and body.
 
         :param subject: The subject of the email.
@@ -48,7 +56,7 @@ class EmailTools(Toolkit):
         msg["To"] = self.receiver_email
         msg.set_content(body)
 
-        logger.info(f"Sending Email to {self.receiver_email}")
+        log_info(f"Sending Email to {self.receiver_email}")
         try:
             with smtplib.SMTP_SSL("smtp.gmail.com", 465) as smtp:
                 smtp.login(self.sender_email, self.sender_passkey)

agno/tools/evm.py

@@ -0,0 +1,129 @@
+from os import getenv
+from typing import Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, log_error
+
+try:
+    from eth_account.account import LocalAccount
+    from eth_account.datastructures import SignedTransaction
+    from hexbytes import HexBytes
+    from web3 import Web3
+    from web3.main import Web3 as Web3Type
+    from web3.providers.rpc import HTTPProvider
+    from web3.types import TxParams, TxReceipt
+except ImportError:
+    raise ImportError("`web3` not installed. Please install using `pip install web3`")
+
+
+class EvmTools(Toolkit):
+    def __init__(
+        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.
+
+        Args:
+            private_key: Private key for signing transactions (defaults to EVM_PRIVATE_KEY env var)
+            rpc_url: RPC URL for blockchain connection (defaults to EVM_RPC_URL env var)
+            **kwargs: Additional arguments passed to parent Toolkit class
+        """
+
+        self.private_key = private_key or getenv("EVM_PRIVATE_KEY")
+        self.rpc_url = rpc_url or getenv("EVM_RPC_URL")
+
+        if not self.private_key:
+            log_error("Private Key is required")
+            raise ValueError("Private Key is required")
+        if not self.rpc_url:
+            log_error("RPC Url is needed to interact with EVM blockchain")
+            raise ValueError("RPC Url is needed to interact with EVM blockchain")
+
+        # Ensure private key has 0x prefix
+        if not self.private_key.startswith("0x"):
+            self.private_key = f"0x{self.private_key}"
+
+        # Initialize Web3 client and account
+        self.web3_client: "Web3Type" = Web3(HTTPProvider(self.rpc_url))
+        self.account: "LocalAccount" = self.web3_client.eth.account.from_key(self.private_key)
+        log_debug(f"Your wallet address is: {self.account.address}")
+
+        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.
+
+        Returns:
+            int: The max priority fee per gas for the transaction (1 gwei)
+        """
+        max_priority_fee_per_gas = self.web3_client.to_wei(1, "gwei")
+        return max_priority_fee_per_gas
+
+    def get_max_fee_per_gas(self, max_priority_fee_per_gas: int) -> int:
+        """Get the max fee per gas for the transaction.
+
+        Args:
+            max_priority_fee_per_gas: The max priority fee per gas
+
+        Returns:
+            int: The max fee per gas for the transaction
+        """
+        latest_block = self.web3_client.eth.get_block("latest")
+        base_fee_per_gas = latest_block.get("baseFeePerGas")
+        if base_fee_per_gas is None:
+            log_error("Base fee per gas not found in the latest block.")
+            raise ValueError("Base fee per gas not found in the latest block.")
+        max_fee_per_gas = (2 * base_fee_per_gas) + max_priority_fee_per_gas
+        return max_fee_per_gas
+
+    def send_transaction(self, to_address: str, amount_in_wei: int) -> str:
+        """Sends a transaction to the address provided.
+
+        Args:
+            to_address: The address to which you want to send ETH
+            amount_in_wei: The amount of ETH to send in wei
+
+        Returns:
+            str: The transaction hash of the transaction or error message
+        """
+        try:
+            max_priority_fee_per_gas = self.get_max_priority_fee_per_gas()
+            max_fee_per_gas = self.get_max_fee_per_gas(max_priority_fee_per_gas)
+
+            transaction_params: "TxParams" = {
+                "from": self.account.address,
+                "to": to_address,
+                "value": amount_in_wei,  # type: ignore[typeddict-item]
+                "nonce": self.web3_client.eth.get_transaction_count(self.account.address),
+                "gas": 21000,
+                "maxFeePerGas": max_fee_per_gas,  # type: ignore[typeddict-item]
+                "maxPriorityFeePerGas": max_priority_fee_per_gas,  # type: ignore[typeddict-item]
+                "chainId": self.web3_client.eth.chain_id,
+                "type": 2,  # EIP-1559 dynamic fee transaction
+            }
+
+            signed_transaction: "SignedTransaction" = self.web3_client.eth.account.sign_transaction(
+                transaction_params, self.private_key
+            )
+            transaction_hash: "HexBytes" = self.web3_client.eth.send_raw_transaction(signed_transaction.raw_transaction)
+            log_debug(f"Ongoing Transaction hash: 0x{transaction_hash.hex()}")
+
+            transaction_receipt: "TxReceipt" = self.web3_client.eth.wait_for_transaction_receipt(transaction_hash)
+            if transaction_receipt.get("status") == 1:
+                log_debug(f"Transaction successful! Transaction hash: 0x{transaction_hash.hex()}")
+                return f"0x{transaction_hash.hex()}"
+            else:
+                log_error("Transaction failed!")
+                raise Exception("Transaction failed!")
+
+        except Exception as e:
+            log_error(f"Error sending transaction: {e}")
+            return f"error: {e}"