agno 2.2.13__py3-none-any.whl

agno/tools/eleven_labs.py

@@ -0,0 +1,196 @@
+from io import BytesIO
+from os import getenv, path
+from pathlib import Path
+from typing import Any, Iterator, List, Literal, Optional, Union
+from uuid import uuid4
+
+from agno.agent import Agent
+from agno.media import Audio
+from agno.team.team import Team
+from agno.tools import Toolkit
+from agno.tools.function import ToolResult
+from agno.utils.log import log_error, log_info
+
+try:
+    from elevenlabs import ElevenLabs  # type: ignore
+except ImportError:
+    raise ImportError("`elevenlabs` not installed. Please install using `pip install elevenlabs`")
+
+ElevenLabsAudioOutputFormat = Literal[
+    "mp3_22050_32",  # mp3 with 22.05kHz sample rate at 32kbps
+    "mp3_44100_32",  # mp3 with 44.1kHz sample rate at 32kbps
+    "mp3_44100_64",  # mp3 with 44.1kHz sample rate at 64kbps
+    "mp3_44100_96",  # mp3 with 44.1kHz sample rate at 96kbps
+    "mp3_44100_128",  # default, mp3 with 44.1kHz sample rate at 128kbps
+    "mp3_44100_192",  # mp3 with 44.1kHz sample rate at 192kbps (Creator tier+)
+    "pcm_16000",  # PCM format (S16LE) with 16kHz sample rate
+    "pcm_22050",  # PCM format (S16LE) with 22.05kHz sample rate
+    "pcm_24000",  # PCM format (S16LE) with 24kHz sample rate
+    "pcm_44100",  # PCM format (S16LE) with 44.1kHz sample rate (Pro tier+)
+    "ulaw_8000",  # μ-law format with 8kHz sample rate (for Twilio)
+]
+
+
+class ElevenLabsTools(Toolkit):
+    def __init__(
+        self,
+        voice_id: str = "JBFqnCBsd6RMkjVDRZzb",
+        api_key: Optional[str] = None,
+        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")
+        if not self.api_key:
+            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
+        self.model_id = model_id
+        self.output_format = output_format
+
+        if self.target_directory:
+            target_path = Path(self.target_directory)
+            target_path.mkdir(parents=True, exist_ok=True)
+
+        self.eleven_labs_client = ElevenLabs(api_key=self.api_key)
+
+        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:
+        """
+        Get all the voices available.
+
+        Returns:
+            result (list): A list of voices that have an ID, name and description.
+        """
+        try:
+            voices = self.eleven_labs_client.voices.get_all()
+
+            response = []
+            for voice in voices.voices:
+                response.append(
+                    {
+                        "id": voice.voice_id,
+                        "name": voice.name,
+                        "description": voice.description,
+                    }
+                )
+
+            return str(response)
+
+        except Exception as e:
+            log_error(f"Failed to fetch voices: {e}")
+            return f"Error: {e}"
+
+    def _process_audio(self, audio_generator: Iterator[bytes]) -> bytes:
+        audio_bytes = BytesIO()
+        for chunk in audio_generator:
+            audio_bytes.write(chunk)
+
+        # Read bytes
+        audio_bytes.seek(0)
+        audio_data = audio_bytes.read()
+
+        # Save to disk if target_directory exists
+        if self.target_directory:
+            # Determine file extension based on output format
+            if self.output_format.startswith("mp3"):
+                extension = "mp3"
+            elif self.output_format.startswith("pcm"):
+                extension = "wav"
+            elif self.output_format.startswith("ulaw"):
+                extension = "ulaw"
+            else:
+                extension = "mp3"
+
+            output_filename = f"{uuid4()}.{extension}"
+            output_path = path.join(self.target_directory, output_filename)
+
+            with open(output_path, "wb") as f:
+                f.write(audio_data)
+
+            log_info(f"Audio saved to: {output_path}")
+
+        return audio_data
+
+    def generate_sound_effect(self, prompt: str, duration_seconds: Optional[float] = None) -> ToolResult:
+        """
+        Generate a sound effect from a text description.
+
+        Args:
+            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:
+            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
+            )
+
+            audio_data = self._process_audio(audio_generator)
+
+            # Create AudioArtifact
+            audio_artifact = Audio(
+                id=str(uuid4()),
+                content=audio_data,
+                mime_type="audio/mpeg",
+            )
+
+            return ToolResult(
+                content="Sound effect generated successfully",
+                audios=[audio_artifact],
+            )
+
+        except Exception as e:
+            log_error(f"Failed to generate sound effect: {e}")
+            return ToolResult(content=f"Error: {e}")
+
+    def text_to_speech(self, agent: Union[Agent, Team], prompt: str) -> ToolResult:
+        """
+        Convert text to speech.
+
+        Args:
+            prompt (str): Text to generate audio from.
+        Returns:
+            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=self.voice_id,
+                model_id=self.model_id,
+                output_format=self.output_format,
+            )
+
+            audio_data = self._process_audio(audio_generator)
+
+            # Create AudioArtifact
+            audio_artifact = Audio(
+                id=str(uuid4()),
+                content=audio_data,
+                mime_type="audio/mpeg",
+            )
+
+            return ToolResult(
+                content="Audio generated successfully",
+                audios=[audio_artifact],
+            )
+
+        except Exception as e:
+            log_error(f"Failed to generate audio: {e}")
+            return ToolResult(content=f"Error: {e}")

agno/tools/email.py

@@ -0,0 +1,67 @@
+from typing import Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_info, logger
+
+
+class EmailTools(Toolkit):
+    def __init__(
+        self,
+        receiver_email: Optional[str] = None,
+        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
+        self.sender_name: Optional[str] = sender_name
+        self.sender_email: Optional[str] = sender_email
+        self.sender_passkey: Optional[str] = sender_passkey
+
+        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.
+        :param body: The body of the email.
+        :return: "success" if the email was sent successfully, "error: [error message]" otherwise.
+        """
+        try:
+            import smtplib
+            from email.message import EmailMessage
+        except ImportError:
+            logger.error("`smtplib` not installed")
+            raise
+
+        if not self.receiver_email:
+            return "error: No receiver email provided"
+        if not self.sender_name:
+            return "error: No sender name provided"
+        if not self.sender_email:
+            return "error: No sender email provided"
+        if not self.sender_passkey:
+            return "error: No sender passkey provided"
+
+        msg = EmailMessage()
+        msg["Subject"] = subject
+        msg["From"] = f"{self.sender_name} <{self.sender_email}>"
+        msg["To"] = self.receiver_email
+        msg.set_content(body)
+
+        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)
+                smtp.send_message(msg)
+        except Exception as e:
+            logger.error(f"Error sending email: {e}")
+            return f"error: {e}"
+        return "email sent successfully"

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}"