agno 1.7.4__py3-none-any.whl → 1.7.6__py3-none-any.whl

agno/tools/evm.py

@@ -0,0 +1,123 @@
+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,
+        **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}")
+
+        super().__init__(name="evm_tools", tools=[self.send_transaction], **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}"

agno/tools/function.py

@@ -151,7 +151,7 @@ class Function(BaseModel):
             param_type_hints = {
                 name: type_hints.get(name)
                 for name in sig.parameters
-                if name != "return" and name not in ["agent", "team"]
+                if name != "return" and name not in ["agent", "team", "self"]
             }
 
             # Parse docstring for parameters
@@ -177,7 +177,9 @@ class Function(BaseModel):
             # If strict=True mark all fields as required
             # See: https://platform.openai.com/docs/guides/structured-outputs/supported-schemas#all-fields-must-be-required
             if strict:
-                parameters["required"] = [name for name in parameters["properties"] if name not in ["agent", "team"]]
+                parameters["required"] = [
+                    name for name in parameters["properties"] if name not in ["agent", "team", "self"]
+                ]
             else:
                 # Mark a field as required if it has no default value (this would include optional fields)
                 parameters["required"] = [
@@ -235,7 +237,7 @@ class Function(BaseModel):
             # log_info(f"Type hints for {self.name}: {type_hints}")
 
             # Filter out return type and only process parameters
-            excluded_params = ["return", "agent", "team"]
+            excluded_params = ["return", "agent", "team", "self"]
             if self.requires_user_input and self.user_input_fields:
                 if len(self.user_input_fields) == 0:
                     excluded_params.extend(list(type_hints.keys()))
@@ -337,7 +339,9 @@ class Function(BaseModel):
 
     def process_schema_for_strict(self):
         self.parameters["additionalProperties"] = False
-        self.parameters["required"] = [name for name in self.parameters["properties"] if name not in ["agent", "team"]]
+        self.parameters["required"] = [
+            name for name in self.parameters["properties"] if name not in ["agent", "team", "self"]
+        ]
 
     def _get_cache_key(self, entrypoint_args: Dict[str, Any], call_args: Optional[Dict[str, Any]] = None) -> str:
         """Generate a cache key based on function name and arguments."""
@@ -554,7 +558,7 @@ class FunctionCall(BaseModel):
         from functools import reduce
         from inspect import iscoroutinefunction
 
-        def execute_entrypoint():
+        def execute_entrypoint(name, func, args):
             """Execute the entrypoint function."""
             arguments = entrypoint_args.copy()
             if self.arguments is not None:
@@ -572,9 +576,9 @@ class FunctionCall(BaseModel):
                 # Pass the inner function as next_func to the hook
                 # The hook will call next_func to continue the chain
                 def next_func(**kwargs):
-                    return inner_func()
+                    return inner_func(name, func, kwargs)
 
-                hook_args = self._build_hook_args(hook, name, func, args)
+                hook_args = self._build_hook_args(hook, name, next_func, args)
 
                 return hook(**hook_args)
 
@@ -716,7 +720,7 @@ class FunctionCall(BaseModel):
         from functools import reduce
         from inspect import isasyncgen, isasyncgenfunction, iscoroutinefunction
 
-        async def execute_entrypoint_async():
+        async def execute_entrypoint_async(name, func, args):
             """Execute the entrypoint function asynchronously."""
             arguments = entrypoint_args.copy()
             if self.arguments is not None:
@@ -729,7 +733,7 @@ class FunctionCall(BaseModel):
                 result = await result
             return result
 
-        def execute_entrypoint():
+        def execute_entrypoint(name, func, args):
             """Execute the entrypoint function synchronously."""
             arguments = entrypoint_args.copy()
             if self.arguments is not None:
@@ -750,11 +754,11 @@ class FunctionCall(BaseModel):
                 # The hook will call next_func to continue the chain
                 async def next_func(**kwargs):
                     if iscoroutinefunction(inner_func):
-                        return await inner_func()
+                        return await inner_func(name, func, kwargs)
                     else:
-                        return inner_func()
+                        return inner_func(name, func, kwargs)
 
-                hook_args = self._build_hook_args(hook, name, func, args)
+                hook_args = self._build_hook_args(hook, name, next_func, args)
 
                 if iscoroutinefunction(hook):
                     return await hook(**hook_args)

agno/tools/linkup.py

@@ -0,0 +1,54 @@
+from os import getenv
+from typing import Any, List, Literal, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import logger
+
+try:
+    from linkup import LinkupClient
+except ImportError:
+    raise ImportError("`linkup-sdk` not installed. Please install using `pip install linkup-sdk`")
+
+
+class LinkupTools(Toolkit):
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        depth: Literal["standard", "deep"] = "standard",
+        output_type: Literal["sourcedAnswer", "searchResults"] = "searchResults",
+        **kwargs,
+    ):
+        self.api_key = api_key or getenv("LINKUP_API_KEY")
+        if not self.api_key:
+            logger.error("LINKUP_API_KEY not set. Please set the LINKUP_API_KEY environment variable.")
+
+        self.linkup = LinkupClient(api_key=api_key)
+        self.depth = depth
+        self.output_type = output_type
+
+        tools: List[Any] = [self.web_search_with_linkup]
+
+        super().__init__(name="linkup_tools", tools=tools, **kwargs)
+
+    def web_search_with_linkup(self, query: str, depth: Optional[str] = None, output_type: Optional[str] = None) -> str:
+        """
+        Use this function to search the web for a given query.
+        This function uses the Linkup API to provide realtime online information about the query.
+
+        Args:
+            query (str): Query to search for.
+            depth (str): (deep|standard) Depth of the search. Defaults to 'standard'.
+            output_type (str): (sourcedAnswer|searchResults) Type of output. Defaults to 'searchResults'.
+
+        Returns:
+            str: string of results related to the query.
+        """
+        try:
+            response = self.linkup.search(
+                query=query,
+                depth=depth or self.depth,  # type: ignore
+                output_type=output_type or self.output_type,  # type: ignore
+            )
+            return response
+        except Exception as e:
+            return f"Error: {str(e)}"

agno/tools/mcp.py

@@ -6,7 +6,7 @@ from typing import Any, Dict, List, Literal, Optional, Union
 
 from agno.tools import Toolkit
 from agno.tools.function import Function
-from agno.utils.log import log_debug, log_warning, logger
+from agno.utils.log import log_debug, log_info, log_warning, logger
 from agno.utils.mcp import get_entrypoint_for_tool
 
 try:
@@ -82,6 +82,9 @@ class MCPTools(Toolkit):
         """
         super().__init__(name="MCPTools", **kwargs)
 
+        if transport == "sse":
+            log_info("SSE as a standalone transport is deprecated. Please use Streamable HTTP instead.")
+
         # Set these after `__init__` to bypass the `_check_tools_filters`
         # because tools are not available until `initialize()` is called.
         self.include_tools = include_tools
@@ -303,10 +306,14 @@ class MultiMCPTools(Toolkit):
         """
         super().__init__(name="MultiMCPTools", **kwargs)
 
+        if urls_transports is not None:
+            if "sse" in urls_transports:
+                log_info("SSE as a standalone transport is deprecated. Please use Streamable HTTP instead.")
+
         if urls is not None:
             if urls_transports is None:
                 log_warning(
-                    "The default transport 'sse' will be used. You can explicitly set the transports by providing the urls_transports parameter."
+                    "The default transport 'streamable-http' will be used. You can explicitly set the transports by providing the urls_transports parameter."
                 )
             else:
                 if len(urls) != len(urls_transports):
@@ -355,7 +362,7 @@ class MultiMCPTools(Toolkit):
                         self.server_params_list.append(SSEClientParams(url=url))
             else:
                 for url in urls:
-                    self.server_params_list.append(SSEClientParams(url=url))
+                    self.server_params_list.append(StreamableHTTPClientParams(url=url))
 
         self._async_exit_stack = AsyncExitStack()
 

agno/tools/mem0.py

@@ -7,7 +7,8 @@ from agno.tools.toolkit import Toolkit
 from agno.utils.log import log_debug, log_error, log_warning
 
 try:
-    from mem0 import Memory, MemoryClient
+    from mem0.client.main import MemoryClient
+    from mem0.memory.main import Memory
 except ImportError:
     raise ImportError("`mem0ai` package not found. Please install it with `pip install mem0ai`")
 
@@ -18,6 +19,8 @@ class Mem0Tools(Toolkit):
         config: Optional[Dict[str, Any]] = None,
         api_key: Optional[str] = None,
         user_id: Optional[str] = None,
+        org_id: Optional[str] = None,
+        project_id: Optional[str] = None,
         infer: bool = True,
         **kwargs,
     ):
@@ -33,13 +36,20 @@ class Mem0Tools(Toolkit):
         )
         self.api_key = api_key or getenv("MEM0_API_KEY")
         self.user_id = user_id
+        self.org_id = org_id or getenv("MEM0_ORG_ID")
+        self.project_id = project_id or getenv("MEM0_PROJECT_ID")
         self.client: Union[Memory, MemoryClient]
         self.infer = infer
 
         try:
             if self.api_key:
                 log_debug("Using Mem0 Platform API key.")
-                self.client = MemoryClient(api_key=self.api_key)
+                client_kwargs = {"api_key": self.api_key}
+                if self.org_id:
+                    client_kwargs["org_id"] = self.org_id
+                if self.project_id:
+                    client_kwargs["project_id"] = self.project_id
+                self.client = MemoryClient(**client_kwargs)
             elif config is not None:
                 log_debug("Using Mem0 with config.")
                 self.client = Memory.from_config(config)
@@ -100,6 +110,7 @@ class Mem0Tools(Toolkit):
                 messages_list,
                 user_id=resolved_user_id,
                 infer=self.infer,
+                output_format="v1.1",
             )
             return json.dumps(result)
         except Exception as e:
@@ -120,6 +131,7 @@ class Mem0Tools(Toolkit):
             results = self.client.search(
                 query=query,
                 user_id=resolved_user_id,
+                output_format="v1.1",
             )
 
             if isinstance(results, dict) and "results" in results:
@@ -147,6 +159,7 @@ class Mem0Tools(Toolkit):
         try:
             results = self.client.get_all(
                 user_id=resolved_user_id,
+                output_format="v1.1",
             )
 
             if isinstance(results, dict) and "results" in results: