chore: Release 1.7.5 (#3885)

# Changelog

## Improvements:

- **Session Caching:** Added `cache_session` attribute to allow users to
switch off session caching, which improves on memory management.

## Bug Fixes:

- **Nested Tool Hooks**: Fixed bug with nested tool hooks.

Author: dirkbrnd

.github/workflows/test_on_release.yml

@@ -252,6 +252,7 @@ jobs:
 
   # Run tests for Mistral
   test-mistral:
+    if: false # Disable mistral tests until we get a production account
     runs-on: ubuntu-latest
     strategy:
       matrix:

cookbook/agent_concepts/tool_concepts/custom_tools/tool_decorator_async.py

@@ -0,0 +1,95 @@
+import asyncio
+import json
+from typing import AsyncIterator
+
+import httpx
+from agno.agent import Agent
+from agno.tools import tool
+
+
+class DemoTools:
+    @tool(description="Get the top hackernews stories")
+    @staticmethod
+    async def get_top_hackernews_stories(agent: Agent) -> str:
+        num_stories = agent.context.get("num_stories", 5) if agent.context else 5
+
+        # Fetch top story IDs
+        response = httpx.get("https://hacker-news.firebaseio.com/v0/topstories.json")
+        story_ids = response.json()
+
+        # Get story details
+        for story_id in story_ids[:num_stories]:
+            async with httpx.AsyncClient() as client:
+                story_response = await client.get(
+                    f"https://hacker-news.firebaseio.com/v0/item/{story_id}.json"
+                )
+            story = story_response.json()
+            if "text" in story:
+                story.pop("text", None)
+            return json.dumps(story)
+
+    @tool(
+        description="Get the current weather for a city using the MetaWeather public API"
+    )
+    async def get_current_weather(agent: Agent) -> str:
+        city = (
+            agent.context.get("city", "San Francisco")
+            if agent.context
+            else "San Francisco"
+        )
+
+        async with httpx.AsyncClient() as client:
+            # Geocode city to get latitude and longitude
+            geo_resp = await client.get(
+                "https://geocoding-api.open-meteo.com/v1/search",
+                params={"name": city, "count": 1, "language": "en", "format": "json"},
+            )
+            geo_data = geo_resp.json()
+            if not geo_data.get("results"):
+                return json.dumps({"error": f"City '{city}' not found."})
+            location = geo_data["results"][0]
+            lat, lon = location["latitude"], location["longitude"]
+
+            # Get current weather
+            weather_resp = await client.get(
+                "https://api.open-meteo.com/v1/forecast",
+                params={
+                    "latitude": lat,
+                    "longitude": lon,
+                    "current_weather": True,
+                    "timezone": "auto",
+                },
+            )
+            weather_data = weather_resp.json()
+            current_weather = weather_data.get("current_weather")
+            if not current_weather:
+                return json.dumps({"error": f"No weather data found for '{city}'."})
+
+            result = {
+                "city": city,
+                "weather_state": f"{current_weather['weathercode']}",  # Open-Meteo uses weather codes
+                "temp_celsius": current_weather["temperature"],
+                "humidity": None,  # Open-Meteo current_weather does not provide humidity
+                "date": current_weather["time"],
+            }
+            return json.dumps(result)
+
+
+agent = Agent(
+    name="HackerNewsAgent",
+    context={
+        "num_stories": 2,
+    },
+    tools=[DemoTools.get_top_hackernews_stories],
+)
+asyncio.run(agent.aprint_response("What are the top hackernews stories?"))
+
+
+agent = Agent(
+    name="WeatherAgent",
+    context={
+        "city": "San Francisco",
+    },
+    tools=[DemoTools().get_current_weather],
+)
+asyncio.run(agent.aprint_response("What is the weather like?"))

libs/agno/agno/agent/agent.py

@@ -1001,10 +1001,10 @@ def run(
         session_id, user_id = self._initialize_session(
             session_id=session_id, user_id=user_id, session_state=session_state
         )
-        
+
         # Initialize the Agent
         self.initialize_agent()
-        
+
         # Read existing session from storage
         self.read_from_storage(session_id=session_id)
 
@@ -1377,16 +1377,15 @@ async def arun(
     ) -> Any:
         """Async Run the Agent and return the response."""
 
-
         session_id, user_id = self._initialize_session(
             session_id=session_id, user_id=user_id, session_state=session_state
         )
 
         log_debug(f"Session ID: {session_id}", center=True)
-        
+
         # Initialize the Agent
         self.initialize_agent()
-        
+
         # Read existing session from storage
         self.read_from_storage(session_id=session_id)
 

libs/agno/agno/app/fastapi/async_router.py

@@ -406,9 +406,7 @@ async def run_agent_or_team_or_workflow(
                         )
                 else:
                     return StreamingResponse(
-                        workflow_response_streamer(
-                            workflow, workflow_input, session_id=session_id, user_id=user_id
-                        ),  # type: ignore
+                        workflow_response_streamer(workflow, workflow_input, session_id=session_id, user_id=user_id),  # type: ignore
                         media_type="text/event-stream",
                     )
         else:

libs/agno/agno/app/fastapi/sync_router.py

@@ -391,11 +391,11 @@ def run_agent_or_team_or_workflow(
                     if isinstance(workflow_input, dict):
                         return StreamingResponse(
                             (json.dumps(asdict(result)) for result in workflow_instance.run(**workflow_input)),
-                        media_type="text/event-stream",
-                    )
+                            media_type="text/event-stream",
+                        )
                     else:
                         return StreamingResponse(
-                            (json.dumps(asdict(result)) for result in workflow_instance.run(workflow_input)),
+                            (json.dumps(asdict(result)) for result in workflow_instance.run(workflow_input)),  # type: ignore
                             media_type="text/event-stream",
                         )
                 else:
@@ -438,7 +438,7 @@ def run_agent_or_team_or_workflow(
                     if isinstance(workflow_input, dict):
                         return workflow_instance.run(**workflow_input).to_dict()
                     else:
-                        return workflow_instance.run(workflow_input).to_dict()
+                        return workflow_instance.run(workflow_input).to_dict()  # type: ignore
                 else:
                     if isinstance(workflow_input, dict):
                         return workflow.run(**workflow_input, session_id=session_id, user_id=user_id).to_dict()

libs/agno/agno/knowledge/combined.py

@@ -32,5 +32,5 @@ async def async_document_lists(self) -> AsyncIterator[List[Document]]:
 
         for kb in self.sources:
             log_debug(f"Loading documents from {kb.__class__.__name__}")
-            async for document in kb.async_document_lists:
+            async for document in kb.async_document_lists:  # type: ignore
                 yield document

libs/agno/agno/team/team.py

@@ -800,7 +800,7 @@ def run(
 
         # Initialize Team
         self.initialize_team(session_id=session_id)
-        
+
         # Read existing session from storage
         self.read_from_storage(session_id=session_id)
 
@@ -1200,10 +1200,10 @@ async def arun(
             session_id=session_id, user_id=user_id, session_state=session_state
         )
         log_debug(f"Session ID: {session_id}", center=True)
-        
+
         # Initialize Team
         self.initialize_team(session_id=session_id)
-        
+
         # Read existing session from storage
         self.read_from_storage(session_id=session_id)
 

libs/agno/agno/tools/decorator.py

@@ -9,6 +9,49 @@
 ToolConfig = TypeVar("ToolConfig", bound=Dict[str, Any])
 
 
+def _is_async_function(func: Callable) -> bool:
+    """
+    Check if a function is async, even when wrapped by decorators like @staticmethod.
+
+    This function tries to detect async functions by:
+    1. Checking the function directly with inspect functions
+    2. Looking at the original function if it's wrapped
+    3. Checking the function's code object for async indicators
+    """
+    from inspect import iscoroutine, iscoroutinefunction
+
+    # First, try the standard inspect functions
+    if iscoroutinefunction(func) or iscoroutine(func):
+        return True
+
+    # If the function has a __wrapped__ attribute, check the original function
+    if hasattr(func, "__wrapped__"):
+        original_func = func.__wrapped__
+        if iscoroutinefunction(original_func) or iscoroutine(original_func):
+            return True
+
+    # Check if the function has CO_COROUTINE flag in its code object
+    try:
+        if hasattr(func, "__code__") and func.__code__.co_flags & 0x80:  # CO_COROUTINE flag
+            return True
+    except (AttributeError, TypeError):
+        pass
+
+    # For static methods, try to get the original function
+    try:
+        if hasattr(func, "__func__"):
+            original_func = func.__func__
+            if iscoroutinefunction(original_func) or iscoroutine(original_func):
+                return True
+            # Check the code object of the original function
+            if hasattr(original_func, "__code__") and original_func.__code__.co_flags & 0x80:
+                return True
+    except (AttributeError, TypeError):
+        pass
+
+    return False
+
+
 @overload
 def tool() -> Callable[[F], Function]: ...
 
@@ -125,7 +168,7 @@ async def my_async_function():
         )
 
     def decorator(func: F) -> Function:
-        from inspect import isasyncgenfunction, iscoroutine, iscoroutinefunction
+        from inspect import isasyncgenfunction
 
         @wraps(func)
         def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
@@ -163,7 +206,7 @@ async def async_gen_wrapper(*args: Any, **kwargs: Any) -> Any:
         # Choose appropriate wrapper based on function type
         if isasyncgenfunction(func):
             wrapper = async_gen_wrapper
-        elif iscoroutinefunction(func) or iscoroutine(func):
+        elif _is_async_function(func):
             wrapper = async_wrapper
         else:
             wrapper = sync_wrapper

libs/agno/agno/tools/function.py

@@ -151,7 +151,7 @@ def from_callable(cls, c: Callable, name: Optional[str] = None, strict: bool = F
             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 @@ def from_callable(cls, c: Callable, name: Optional[str] = None, strict: bool = F
             # 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 @@ def process_entrypoint(self, strict: bool = False):
             # 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 @@ def _wrap_callable(func: Callable) -> Callable:
 
     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."""

libs/agno/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agno"
-version = "1.7.4"
+version = "1.7.5"
 description = "Agno: a lightweight library for building Multi-Agent Systems"
 requires-python = ">=3.7,<4"
 readme = "README.md"