agno 2.3.22__py3-none-any.whl → 2.3.24__py3-none-any.whl

agno/tools/toolkit.py

@@ -1,8 +1,10 @@
 from collections import OrderedDict
-from typing import Any, Callable, Dict, List, Optional, Sequence, Union
+from inspect import iscoroutinefunction
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
 
 from agno.tools.function import Function
-from agno.utils.log import log_debug, log_warning, logger
+from agno.utils.log import log_debug, log_error, log_warning, logger
 
 
 class Toolkit:
@@ -14,6 +16,7 @@ class Toolkit:
         self,
         name: str = "toolkit",
         tools: Sequence[Union[Callable[..., Any], Function]] = [],
+        async_tools: Optional[Sequence[tuple[Callable[..., Any], str]]] = None,
         instructions: Optional[str] = None,
         add_instructions: bool = False,
         include_tools: Optional[list[str]] = None,
@@ -32,6 +35,9 @@ class Toolkit:
         Args:
             name: A descriptive name for the toolkit
             tools: List of tools to include in the toolkit (can be callables or Function objects from @tool decorator)
+            async_tools: List of (async_callable, tool_name) tuples for async variants.
+                        Used when async methods have different names than sync methods.
+                        Example: [(self.anavigate_to, "navigate_to"), (self.ascreenshot, "screenshot")]
             instructions: Instructions for the toolkit
             add_instructions: Whether to add instructions to the toolkit
             include_tools: List of tool names to include in the toolkit
@@ -47,7 +53,11 @@ class Toolkit:
         """
         self.name: str = name
         self.tools: Sequence[Union[Callable[..., Any], Function]] = tools
+        self._async_tools: Sequence[tuple[Callable[..., Any], str]] = async_tools or []
+        # Functions dict - used by agent.run() and agent.print_response()
         self.functions: Dict[str, Function] = OrderedDict()
+        # Async functions dict - used by agent.arun() and agent.aprint_response()
+        self.async_functions: Dict[str, Function] = OrderedDict()
         self.instructions: Optional[str] = instructions
         self.add_instructions: bool = add_instructions
 
@@ -71,8 +81,11 @@ class Toolkit:
         self.cache_dir: Optional[str] = cache_dir
 
         # Automatically register all methods if auto_register is True
-        if auto_register and self.tools:
-            self._register_tools()
+        if auto_register:
+            if self.tools:
+                self._register_tools()
+            if self._async_tools:
+                self._register_async_tools()
 
     def _get_tool_name(self, tool: Union[Callable[..., Any], Function]) -> str:
         """Get the name of a tool, whether it's a Function or callable."""
@@ -125,14 +138,25 @@ class Toolkit:
                 log_warning(f"Show result tool(s) not present in the toolkit: {', '.join(missing_show_result)}")
 
     def _register_tools(self) -> None:
-        """Register all tools."""
+        """Register all sync tools."""
         for tool in self.tools:
             self.register(tool)
 
+    def _register_async_tools(self) -> None:
+        """Register all async tools with their mapped names.
+
+        Async detection is automatic via iscoroutinefunction.
+        """
+        for async_func, tool_name in self._async_tools:
+            self.register(async_func, name=tool_name)
+
     def register(self, function: Union[Callable[..., Any], Function], name: Optional[str] = None) -> None:
         """Register a function with the toolkit.
 
         This method supports both regular callables and Function objects (from @tool decorator).
+        Automatically detects if the function is async (using iscoroutinefunction) and registers
+        it to the appropriate dict (functions for sync, async_functions for async).
+
         When a Function object is passed (e.g., from a @tool decorated method), it will:
         1. Extract the configuration from the Function object
         2. Look for a bound method with the same name on `self`
@@ -140,17 +164,18 @@ class Toolkit:
 
         Args:
             function: The callable or Function object to register
-            name: Optional custom name for the function
-
-        Returns:
-            The registered function
+            name: Optional custom name for the function (useful for aliasing)
         """
         try:
             # Handle Function objects (from @tool decorator)
             if isinstance(function, Function):
-                return self._register_decorated_tool(function, name)
+                # Auto-detect if this is an async function
+                is_async = function.entrypoint is not None and iscoroutinefunction(function.entrypoint)
+                return self._register_decorated_tool(function, name, is_async=is_async)
+
+            # Handle regular callables - auto-detect async
+            is_async = iscoroutinefunction(function)
 
-            # Handle regular callables
             tool_name = name or function.__name__
             if self.include_tools is not None and tool_name not in self.include_tools:
                 return
@@ -168,14 +193,19 @@ class Toolkit:
                 stop_after_tool_call=tool_name in self.stop_after_tool_call_tools,
                 show_result=tool_name in self.show_result_tools or tool_name in self.stop_after_tool_call_tools,
             )
-            self.functions[f.name] = f
-            log_debug(f"Function: {f.name} registered with {self.name}")
+
+            if is_async:
+                self.async_functions[f.name] = f
+                log_debug(f"Async function: {f.name} registered with {self.name}")
+            else:
+                self.functions[f.name] = f
+                log_debug(f"Function: {f.name} registered with {self.name}")
         except Exception as e:
             func_name = self._get_tool_name(function)
             logger.warning(f"Failed to create Function for: {func_name}")
             raise e
 
-    def _register_decorated_tool(self, function: Function, name: Optional[str] = None) -> None:
+    def _register_decorated_tool(self, function: Function, name: Optional[str] = None, is_async: bool = False) -> None:
         """Register a Function object from @tool decorator, binding it to self.
 
         When @tool decorator is used on a class method, it creates a Function with an unbound
@@ -185,6 +215,7 @@ class Toolkit:
         Args:
             function: The Function object from @tool decorator
             name: Optional custom name override
+            is_async: If True, register to async_functions dict instead of functions
         """
         import inspect
 
@@ -207,14 +238,24 @@ class Toolkit:
 
         if params and params[0] == "self":
             # Create a bound method by wrapping the function to include self
-            def make_bound_method(func, instance):
-                def bound(*args, **kwargs):
-                    return func(instance, *args, **kwargs)
+            if is_async:
 
-                # Preserve function metadata for debugging
-                bound.__name__ = getattr(func, "__name__", tool_name)
-                bound.__doc__ = getattr(func, "__doc__", None)
-                return bound
+                def make_bound_method(func, instance):
+                    async def bound(*args, **kwargs):
+                        return await func(instance, *args, **kwargs)
+
+                    bound.__name__ = getattr(func, "__name__", tool_name)
+                    bound.__doc__ = getattr(func, "__doc__", None)
+                    return bound
+            else:
+
+                def make_bound_method(func, instance):
+                    def bound(*args, **kwargs):
+                        return func(instance, *args, **kwargs)
+
+                    bound.__name__ = getattr(func, "__name__", tool_name)
+                    bound.__doc__ = getattr(func, "__doc__", None)
+                    return bound
 
             bound_method = make_bound_method(original_func, self)
         else:
@@ -251,8 +292,36 @@ class Toolkit:
             cache_dir=function.cache_dir if function.cache_dir else self.cache_dir,
             cache_ttl=function.cache_ttl if function.cache_ttl != 3600 else self.cache_ttl,
         )
-        self.functions[f.name] = f
-        log_debug(f"Function: {f.name} registered with {self.name} (from @tool decorator)")
+
+        if is_async:
+            self.async_functions[f.name] = f
+            log_debug(f"Async function: {f.name} registered with {self.name} (from @tool decorator)")
+        else:
+            self.functions[f.name] = f
+            log_debug(f"Function: {f.name} registered with {self.name} (from @tool decorator)")
+
+    def get_functions(self) -> Dict[str, Function]:
+        """Get sync functions dict.
+
+        Returns:
+            Dict of function name to Function for sync execution
+        """
+        return self.functions
+
+    def get_async_functions(self) -> Dict[str, Function]:
+        """Get functions dict optimized for async execution.
+
+        Returns a merged dict where async_functions take precedence over functions.
+        This allows async-optimized implementations to be automatically used in async contexts,
+        while falling back to sync implementations for tools without async variants.
+
+        Returns:
+            Dict of function name to Function, with async variants preferred
+        """
+        # Merge: start with sync functions, override with async variants
+        merged = OrderedDict(self.functions)
+        merged.update(self.async_functions)
+        return merged
 
     @property
     def requires_connect(self) -> bool:
@@ -275,6 +344,36 @@ class Toolkit:
         """
         pass
 
+    def _check_path(self, file_name: str, base_dir: Path, restrict_to_base_dir: bool = True) -> Tuple[bool, Path]:
+        """Check if the file path is within the base directory.
+
+        This method validates that a given file path resolves to a location
+        within the specified base_dir, preventing directory traversal attacks.
+
+        Args:
+            file_name: The file name or relative path to check.
+            base_dir: The base directory to validate against.
+            restrict_to_base_dir: If True, reject paths outside base_dir.
+
+        Returns:
+            Tuple of (is_safe, resolved_path). If not safe, returns base_dir as the path.
+        """
+        file_path = base_dir.joinpath(file_name).resolve()
+
+        if not restrict_to_base_dir:
+            return True, file_path
+
+        if base_dir == file_path:
+            return True, file_path
+
+        try:
+            file_path.relative_to(base_dir)
+        except ValueError:
+            log_error(f"Path escapes base directory: {file_name}")
+            return False, base_dir
+
+        return True, file_path
+
     def __repr__(self):
         return f"<{self.__class__.__name__} name={self.name} functions={list(self.functions.keys())}>"
 

agno/vectordb/cassandra/cassandra.py

@@ -32,7 +32,7 @@ class Cassandra(VectorDb):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             embedder = OpenAIEmbedder()
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
         # Initialize base class with name and description
         super().__init__(name=name, description=description)
 

agno/vectordb/chroma/chromadb.py

@@ -117,7 +117,7 @@ class ChromaDb(VectorDb):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             embedder = OpenAIEmbedder()
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
         self.embedder: Embedder = embedder
         # Distance metric
         self.distance: Distance = distance

agno/vectordb/clickhouse/clickhousedb.py

@@ -71,7 +71,7 @@ class Clickhouse(VectorDb):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             _embedder = OpenAIEmbedder()
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
         self.embedder: Embedder = _embedder
         self.dimensions: Optional[int] = self.embedder.dimensions
 

agno/vectordb/couchbase/couchbase.py

@@ -100,7 +100,7 @@ class CouchbaseSearch(VectorDb):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             embedder = OpenAIEmbedder()
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
         self.embedder = embedder
         self.overwrite = overwrite
         self.is_global_level_index = is_global_level_index

agno/vectordb/milvus/milvus.py

@@ -89,7 +89,7 @@ class Milvus(VectorDb):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             embedder = OpenAIEmbedder()
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
         self.embedder: Embedder = embedder
         self.dimensions: Optional[int] = self.embedder.dimensions
 

agno/vectordb/mongodb/mongodb.py

@@ -1,5 +1,6 @@
 import asyncio
 import time
+from importlib import metadata
 from typing import Any, Dict, List, Optional, Union
 
 from bson import ObjectId
@@ -20,11 +21,14 @@ except ImportError:
 try:
     from pymongo import AsyncMongoClient, MongoClient, errors
     from pymongo.collection import Collection
+    from pymongo.driver_info import DriverInfo
     from pymongo.operations import SearchIndexModel
 
 except ImportError:
     raise ImportError("`pymongo` not installed. Please install using `pip install pymongo`")
 
+DRIVER_METADATA = DriverInfo(name="Agno", version=metadata.version("agno"))
+
 
 class MongoDb(VectorDb):
     """
@@ -110,7 +114,7 @@ class MongoDb(VectorDb):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             embedder = OpenAIEmbedder()
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
         self.embedder = embedder
 
         self.distance_metric = distance_metric
@@ -135,6 +139,11 @@ class MongoDb(VectorDb):
         self._async_db = None
         self._async_collection: Optional[Collection] = None
 
+        if self._client is not None:
+            # append_metadata was added in PyMongo 4.14.0, but is a valid database name on earlier versions
+            if callable(self._client.append_metadata):
+                self._client.append_metadata(DRIVER_METADATA)
+
     def _get_client(self) -> MongoClient:
         """Create or retrieve the MongoDB client."""
         if self._client is None:
@@ -157,7 +166,7 @@ class MongoDb(VectorDb):
                         warnings.filterwarnings(
                             "ignore", category=UserWarning, message=".*connected to a CosmosDB cluster.*"
                         )
-                        self._client = MongoClient(self.connection_string, **cosmos_kwargs)  # type: ignore
+                        self._client = MongoClient(self.connection_string, **cosmos_kwargs, driver=DRIVER_METADATA)  # type: ignore
 
                         self._client.admin.command("ping")
 
@@ -173,7 +182,7 @@ class MongoDb(VectorDb):
             else:
                 try:
                     log_debug("Creating MongoDB Client")
-                    self._client = MongoClient(self.connection_string, **self.kwargs)
+                    self._client = MongoClient(self.connection_string, **self.kwargs, driver=DRIVER_METADATA)  # type: ignore
                     # Trigger a connection to verify the client
                     self._client.admin.command("ping")
                     log_info("Connected to MongoDB successfully.")
@@ -195,6 +204,7 @@ class MongoDb(VectorDb):
                 maxPoolSize=self.kwargs.get("maxPoolSize", 100),
                 retryWrites=self.kwargs.get("retryWrites", True),
                 serverSelectionTimeoutMS=5000,
+                driver=DRIVER_METADATA,
             )
             # Verify connection
             try:

agno/vectordb/pgvector/pgvector.py

@@ -122,7 +122,7 @@ class PgVector(VectorDb):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             embedder = OpenAIEmbedder()
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
         self.embedder: Embedder = embedder
         self.dimensions: Optional[int] = self.embedder.dimensions
 

agno/vectordb/pineconedb/pineconedb.py

@@ -26,7 +26,7 @@ from agno.filters import FilterExpr
 from agno.knowledge.document import Document
 from agno.knowledge.embedder import Embedder
 from agno.knowledge.reranker.base import Reranker
-from agno.utils.log import log_debug, log_info, log_warning, logger
+from agno.utils.log import log_debug, log_warning, logger
 from agno.vectordb.base import VectorDb
 
 
@@ -136,7 +136,7 @@ class PineconeDb(VectorDb):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             _embedder = OpenAIEmbedder()
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
         self.embedder: Embedder = _embedder
         self.reranker: Optional[Reranker] = reranker
 

agno/vectordb/qdrant/qdrant.py

@@ -102,7 +102,7 @@ class Qdrant(VectorDb):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             embedder = OpenAIEmbedder()
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
 
         self.embedder: Embedder = embedder
         self.dimensions: Optional[int] = self.embedder.dimensions

agno/vectordb/redis/redisdb.py

@@ -16,7 +16,7 @@ from agno.filters import FilterExpr
 from agno.knowledge.document import Document
 from agno.knowledge.embedder import Embedder
 from agno.knowledge.reranker.base import Reranker
-from agno.utils.log import log_debug, log_error, log_info, log_warning
+from agno.utils.log import log_debug, log_error, log_warning
 from agno.utils.string import hash_string_sha256
 from agno.vectordb.base import VectorDb
 from agno.vectordb.distance import Distance
@@ -80,7 +80,7 @@ class RedisDB(VectorDb):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             embedder = OpenAIEmbedder()
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
 
         self.embedder: Embedder = embedder
         self.dimensions: Optional[int] = self.embedder.dimensions

agno/vectordb/singlestore/singlestore.py

@@ -56,7 +56,7 @@ class SingleStore(VectorDb):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             embedder = OpenAIEmbedder()
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
         self.embedder: Embedder = embedder
         self.dimensions: Optional[int] = self.embedder.dimensions
 

agno/vectordb/surrealdb/surrealdb.py

@@ -14,7 +14,7 @@ except ImportError as e:
 from agno.filters import FilterExpr
 from agno.knowledge.document import Document
 from agno.knowledge.embedder import Embedder
-from agno.utils.log import log_debug, log_error, log_info, log_warning
+from agno.utils.log import log_debug, log_error, log_warning
 from agno.vectordb.base import VectorDb
 from agno.vectordb.distance import Distance
 
@@ -135,7 +135,7 @@ class SurrealDb(VectorDb):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             embedder = OpenAIEmbedder()
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
         self.embedder: Embedder = embedder
         self.dimensions = self.embedder.dimensions
         self.collection = collection

agno/vectordb/weaviate/weaviate.py

@@ -81,7 +81,7 @@ class Weaviate(VectorDb):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             embedder = OpenAIEmbedder()
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
         self.embedder: Embedder = embedder
 
         # Search setup

agno/workflow/remote.py

@@ -340,7 +340,7 @@ class RemoteWorkflow(BaseRemote):
         )
         return map_task_result_to_workflow_run_output(task_result, workflow_id=self.workflow_id, user_id=user_id)
 
-    async def cancel_run(self, run_id: str, auth_token: Optional[str] = None) -> bool:
+    async def acancel_run(self, run_id: str, auth_token: Optional[str] = None) -> bool:
         """Cancel a running workflow execution.
 
         Args:

agno/workflow/workflow.py

@@ -36,6 +36,9 @@ from agno.models.message import Message
 from agno.models.metrics import Metrics
 from agno.run import RunContext, RunStatus
 from agno.run.agent import RunContentEvent, RunEvent, RunOutput
+from agno.run.cancel import (
+    acancel_run as acancel_run_global,
+)
 from agno.run.cancel import (
     acleanup_run,
     araise_if_cancelled,
@@ -3496,6 +3499,17 @@ class Workflow:
         """
         return cancel_run_global(run_id)
 
+    async def acancel_run(self, run_id: str) -> bool:
+        """Cancel a running workflow execution (async version).
+
+        Args:
+            run_id (str): The run_id to cancel.
+
+        Returns:
+            bool: True if the run was found and marked for cancellation, False otherwise.
+        """
+        return await acancel_run_global(run_id)
+
     @overload
     def run(
         self,

{agno-2.3.22.dist-info → agno-2.3.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 2.3.22
+Version: 2.3.24
 Summary: Agno: a lightweight library for building Multi-Agent Systems
 Author-email: Ashpreet Bedi <ashpreet@agno.com>
 Project-URL: homepage, https://agno.com