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

agno/models/base.py

@@ -1016,6 +1016,8 @@ class Model(ABC):
             model_response.extra.update(provider_response.extra)
         if provider_response.provider_data is not None:
             model_response.provider_data = provider_response.provider_data
+        if provider_response.response_usage is not None:
+            model_response.response_usage = provider_response.response_usage
 
     async def _aprocess_model_response(
         self,
@@ -1073,6 +1075,8 @@ class Model(ABC):
             model_response.extra.update(provider_response.extra)
         if provider_response.provider_data is not None:
             model_response.provider_data = provider_response.provider_data
+        if provider_response.response_usage is not None:
+            model_response.response_usage = provider_response.response_usage
 
     def _populate_assistant_message(
         self,

agno/models/google/gemini.py

@@ -466,7 +466,12 @@ class Gemini(Model):
 
         except (ClientError, ServerError) as e:
             log_error(f"Error from Gemini API: {e}")
-            error_message = str(e.response) if hasattr(e, "response") else str(e)
+            error_message = str(e)
+            if hasattr(e, "response"):
+                if hasattr(e.response, "text"):
+                    error_message = e.response.text
+                else:
+                    error_message = str(e.response)
             raise ModelProviderError(
                 message=error_message,
                 status_code=e.code if hasattr(e, "code") and e.code is not None else 502,
@@ -518,8 +523,14 @@ class Gemini(Model):
 
         except (ClientError, ServerError) as e:
             log_error(f"Error from Gemini API: {e}")
+            error_message = str(e)
+            if hasattr(e, "response"):
+                if hasattr(e.response, "text"):
+                    error_message = e.response.text
+                else:
+                    error_message = str(e.response)
             raise ModelProviderError(
-                message=str(e.response) if hasattr(e, "response") else str(e),
+                message=error_message,
                 status_code=e.code if hasattr(e, "code") and e.code is not None else 502,
                 model_name=self.name,
                 model_id=self.id,
@@ -574,8 +585,14 @@ class Gemini(Model):
 
         except (ClientError, ServerError) as e:
             log_error(f"Error from Gemini API: {e}")
+            error_message = str(e)
+            if hasattr(e, "response"):
+                if hasattr(e.response, "text"):
+                    error_message = e.response.text
+                else:
+                    error_message = str(e.response)
             raise ModelProviderError(
-                message=str(e.response) if hasattr(e, "response") else str(e),
+                message=error_message,
                 status_code=e.code if hasattr(e, "code") and e.code is not None else 502,
                 model_name=self.name,
                 model_id=self.id,
@@ -628,8 +645,14 @@ class Gemini(Model):
 
         except (ClientError, ServerError) as e:
             log_error(f"Error from Gemini API: {e}")
+            error_message = str(e)
+            if hasattr(e, "response"):
+                if hasattr(e.response, "text"):
+                    error_message = e.response.text
+                else:
+                    error_message = str(e.response)
             raise ModelProviderError(
-                message=str(e.response) if hasattr(e, "response") else str(e),
+                message=error_message,
                 status_code=e.code if hasattr(e, "code") and e.code is not None else 502,
                 model_name=self.name,
                 model_id=self.id,

agno/os/routers/agents/router.py

@@ -409,7 +409,7 @@ def get_agent_router(
         if agent is None:
             raise HTTPException(status_code=404, detail="Agent not found")
 
-        cancelled = agent.cancel_run(run_id=run_id)
+        cancelled = await agent.acancel_run(run_id=run_id)
         if not cancelled:
             raise HTTPException(status_code=500, detail="Failed to cancel run - run not found or already completed")
 

agno/os/routers/evals/evals.py

@@ -118,8 +118,8 @@ def attach_routes(
         model_id: Optional[str] = Query(default=None, description="Model ID"),
         filter_type: Optional[EvalFilterType] = Query(default=None, description="Filter type", alias="type"),
         eval_types: Optional[List[EvalType]] = Depends(parse_eval_types_filter),
-        limit: Optional[int] = Query(default=20, description="Number of eval runs to return"),
-        page: Optional[int] = Query(default=1, description="Page number"),
+        limit: Optional[int] = Query(default=20, description="Number of eval runs to return", ge=1),
+        page: Optional[int] = Query(default=1, description="Page number", ge=0),
         sort_by: Optional[str] = Query(default="created_at", description="Field to sort by"),
         sort_order: Optional[SortOrder] = Query(default="desc", description="Sort order (asc or desc)"),
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),

agno/os/routers/knowledge/knowledge.py

@@ -344,8 +344,8 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Union[Knowledge,
     )
     async def get_content(
         request: Request,
-        limit: Optional[int] = Query(default=20, description="Number of content entries to return"),
-        page: Optional[int] = Query(default=1, description="Page number"),
+        limit: Optional[int] = Query(default=20, description="Number of content entries to return", ge=1),
+        page: Optional[int] = Query(default=1, description="Page number", ge=0),
         sort_by: Optional[str] = Query(default="created_at", description="Field to sort by"),
         sort_order: Optional[SortOrder] = Query(default="desc", description="Sort order (asc or desc)"),
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),

agno/os/routers/knowledge/schemas.py

@@ -156,7 +156,7 @@ class VectorSearchRequestSchema(BaseModel):
     class Meta(BaseModel):
         """Inline metadata schema for pagination."""
 
-        limit: int = Field(20, description="Number of results per page", ge=1, le=100)
+        limit: int = Field(20, description="Number of results per page", ge=1)
         page: int = Field(1, description="Page number", ge=1)
 
     query: str = Field(..., description="The search query text")

agno/os/routers/memory/memory.py

@@ -256,8 +256,8 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
         team_id: Optional[str] = Query(default=None, description="Filter memories by team ID"),
         topics: Optional[List[str]] = Depends(parse_topics),
         search_content: Optional[str] = Query(default=None, description="Fuzzy search within memory content"),
-        limit: Optional[int] = Query(default=20, description="Number of memories to return per page"),
-        page: Optional[int] = Query(default=1, description="Page number for pagination"),
+        limit: Optional[int] = Query(default=20, description="Number of memories to return per page", ge=1),
+        page: Optional[int] = Query(default=1, description="Page number for pagination", ge=0),
         sort_by: Optional[str] = Query(default="updated_at", description="Field to sort memories by"),
         sort_order: Optional[SortOrder] = Query(default="desc", description="Sort order (asc or desc)"),
         db_id: Optional[str] = Query(default=None, description="Database ID to query memories from"),
@@ -558,8 +558,8 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
     )
     async def get_user_memory_stats(
         request: Request,
-        limit: Optional[int] = Query(default=20, description="Number of user statistics to return per page"),
-        page: Optional[int] = Query(default=1, description="Page number for pagination"),
+        limit: Optional[int] = Query(default=20, description="Number of user statistics to return per page", ge=1),
+        page: Optional[int] = Query(default=1, description="Page number for pagination", ge=0),
         db_id: Optional[str] = Query(default=None, description="Database ID to query statistics from"),
         table: Optional[str] = Query(default=None, description="Table to query statistics from"),
     ) -> PaginatedResponse[UserStatsSchema]:

agno/os/routers/session/session.py

@@ -107,8 +107,8 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
         ),
         user_id: Optional[str] = Query(default=None, description="Filter sessions by user ID"),
         session_name: Optional[str] = Query(default=None, description="Filter sessions by name (partial match)"),
-        limit: Optional[int] = Query(default=20, description="Number of sessions to return per page"),
-        page: Optional[int] = Query(default=1, description="Page number for pagination"),
+        limit: Optional[int] = Query(default=20, description="Number of sessions to return per page", ge=1),
+        page: Optional[int] = Query(default=1, description="Page number for pagination", ge=0),
         sort_by: Optional[str] = Query(default="created_at", description="Field to sort sessions by"),
         sort_order: Optional[SortOrder] = Query(default="desc", description="Sort order (asc or desc)"),
         db_id: Optional[str] = Query(default=None, description="Database ID to query sessions from"),

agno/os/routers/teams/router.py

@@ -95,7 +95,7 @@ async def team_response_streamer(
         )
         yield format_sse_event(error_response)
 
-    except Exception as e:
+    except BaseException as e:
         import traceback
 
         traceback.print_exc()
@@ -325,7 +325,7 @@ def get_team_router(
         if team is None:
             raise HTTPException(status_code=404, detail="Team not found")
 
-        cancelled = team.cancel_run(run_id=run_id)
+        cancelled = await team.acancel_run(run_id=run_id)
         if not cancelled:
             raise HTTPException(status_code=500, detail="Failed to cancel run - run not found or already completed")
 

agno/os/routers/traces/traces.py

@@ -126,8 +126,8 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
             default=None,
             description="Filter traces ending before this time (ISO 8601 format with timezone, e.g., '2025-11-19T11:00:00Z' or '2025-11-19T16:30:00+05:30'). Times are converted to UTC for comparison.",
         ),
-        page: int = Query(default=1, description="Page number (1-indexed)", ge=1),
-        limit: int = Query(default=20, description="Number of traces per page", ge=1, le=100),
+        page: int = Query(default=1, description="Page number (1-indexed)", ge=0),
+        limit: int = Query(default=20, description="Number of traces per page", ge=1),
         db_id: Optional[str] = Query(default=None, description="Database ID to query traces from"),
     ):
         """Get list of traces with optional filters and pagination"""
@@ -455,7 +455,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
             description="Filter sessions with traces created before this time (ISO 8601 format with timezone, e.g., '2025-11-19T11:00:00Z' or '2025-11-19T16:30:00+05:30'). Times are converted to UTC for comparison.",
         ),
         page: int = Query(default=1, description="Page number (1-indexed)", ge=1),
-        limit: int = Query(default=20, description="Number of sessions per page", ge=1, le=100),
+        limit: int = Query(default=20, description="Number of sessions per page", ge=1),
         db_id: Optional[str] = Query(default=None, description="Database ID to query statistics from"),
     ):
         """Get trace statistics grouped by session"""

agno/os/routers/workflows/router.py

@@ -721,7 +721,7 @@ def get_workflow_router(
         if workflow is None:
             raise HTTPException(status_code=404, detail="Workflow not found")
 
-        cancelled = workflow.cancel_run(run_id=run_id)
+        cancelled = await workflow.acancel_run(run_id=run_id)
         if not cancelled:
             raise HTTPException(status_code=500, detail="Failed to cancel run - run not found or already completed")
 

agno/os/schema.py

@@ -549,7 +549,7 @@ class SortOrder(str, Enum):
 
 class PaginationInfo(BaseModel):
     page: int = Field(0, description="Current page number (0-indexed)", ge=0)
-    limit: int = Field(20, description="Number of items per page", ge=1, le=100)
+    limit: int = Field(20, description="Number of items per page", ge=1)
     total_pages: int = Field(0, description="Total number of pages", ge=0)
     total_count: int = Field(0, description="Total count of items", ge=0)
     search_time_ms: float = Field(0, description="Search execution time in milliseconds", ge=0)

agno/remote/base.py

@@ -577,5 +577,5 @@ class BaseRemote:
         raise NotImplementedError("acontinue_run method must be implemented by the subclass")
 
     @abstractmethod
-    async def cancel_run(self, run_id: str) -> bool:
+    async def acancel_run(self, run_id: str) -> bool:
         raise NotImplementedError("cancel_run method must be implemented by the subclass")

agno/team/remote.py

@@ -425,7 +425,7 @@ class RemoteTeam(BaseRemote):
         )
         return map_task_result_to_team_run_output(task_result, team_id=self.team_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 team execution.
 
         Args:

agno/team/team.py

@@ -56,6 +56,9 @@ from agno.models.utils import get_model
 from agno.reasoning.step import NextAction, ReasoningStep, ReasoningSteps
 from agno.run import RunContext, RunStatus
 from agno.run.agent import RunEvent, RunOutput, RunOutputEvent
+from agno.run.cancel import (
+    acancel_run as acancel_run_global,
+)
 from agno.run.cancel import (
     acleanup_run,
     araise_if_cancelled,
@@ -1011,6 +1014,18 @@ class Team:
         """
         return cancel_run_global(run_id)
 
+    @staticmethod
+    async def acancel_run(run_id: str) -> bool:
+        """Cancel a running team execution.
+
+        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)
+
     async def _connect_mcp_tools(self) -> None:
         """Connect the MCP tools to the agent."""
         if self.tools is not None:
@@ -2652,6 +2667,8 @@ class Team:
         """
         log_debug(f"Team Run Start: {run_response.run_id}", center=True)
 
+        await aregister_run(run_context.run_id)
+
         memory_task = None
 
         try:
@@ -5367,7 +5384,8 @@ class Team:
 
             elif isinstance(tool, Toolkit):
                 # For each function in the toolkit and process entrypoint
-                for name, _func in tool.functions.items():
+                toolkit_functions = tool.get_async_functions() if async_mode else tool.get_functions()
+                for name, _func in toolkit_functions.items():
                     if name in _function_names:
                         continue
                     _function_names.append(name)

agno/tools/brandfetch.py

@@ -1,9 +1,10 @@
 """
-Going to contribute this to agno toolkits.
+Brandfetch API toolkit for retrieving brand data and searching brands.
 """
 
+import warnings
 from os import getenv
-from typing import Any, Optional
+from typing import Any, List, Optional
 
 try:
     import httpx
@@ -31,8 +32,6 @@ class BrandfetchTools(Toolkit):
     all: bool - if True, will use all tools
     enable_search_by_identifier: bool - if True, will use search by identifier
     enable_search_by_brand: bool - if True, will use search by brand
-    enable_asearch_by_identifier: bool - if True, will use async search by identifier
-    enable_asearch_by_brand: bool - if True, will use async search by brand
     """
 
     def __init__(
@@ -44,9 +43,18 @@ class BrandfetchTools(Toolkit):
         enable_search_by_identifier: bool = True,
         enable_search_by_brand: bool = False,
         all: bool = False,
-        async_tools: bool = False,
+        async_tools: bool = False,  # Deprecated
         **kwargs,
     ):
+        # Handle deprecated async_tools parameter
+        if async_tools:
+            warnings.warn(
+                "The 'async_tools' parameter is deprecated and will be removed in a future version. "
+                "Async tools are now automatically used when calling agent.arun() or agent.aprint_response().",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
         self.api_key = api_key or getenv("BRANDFETCH_API_KEY")
         self.client_id = client_id or getenv("BRANDFETCH_CLIENT_ID")
         self.base_url = base_url
@@ -54,20 +62,21 @@ class BrandfetchTools(Toolkit):
         self.search_url = f"{self.base_url}/search"
         self.brand_url = f"{self.base_url}/brands"
 
-        tools: list[Any] = []
-        # Backward-compat mapping: prefer new enable_* flags, but honor legacy toggles
-        if async_tools:
-            if all or enable_search_by_identifier:
-                tools.append(self.asearch_by_identifier)
-            if all or enable_search_by_brand:
-                tools.append(self.asearch_by_brand)
-        else:
-            if all or enable_search_by_identifier:
-                tools.append(self.search_by_identifier)
-            if all or enable_search_by_brand:
-                tools.append(self.search_by_brand)
+        # Build tools lists
+        # sync tools: used by agent.run() and agent.print_response()
+        # async tools: used by agent.arun() and agent.aprint_response()
+        tools: List[Any] = []
+        async_tools_list: List[tuple] = []
+
+        if all or enable_search_by_identifier:
+            tools.append(self.search_by_identifier)
+            async_tools_list.append((self.asearch_by_identifier, "search_by_identifier"))
+        if all or enable_search_by_brand:
+            tools.append(self.search_by_brand)
+            async_tools_list.append((self.asearch_by_brand, "search_by_brand"))
+
         name = kwargs.pop("name", "brandfetch_tools")
-        super().__init__(name=name, tools=tools, **kwargs)
+        super().__init__(name=name, tools=tools, async_tools=async_tools_list, **kwargs)
 
     async def asearch_by_identifier(self, identifier: str) -> dict[str, Any]:
         """

agno/tools/browserbase.py

@@ -10,13 +10,6 @@ try:
 except ImportError:
     raise ImportError("`browserbase` not installed. Please install using `pip install browserbase`")
 
-try:
-    from playwright.sync_api import sync_playwright
-except ImportError:
-    raise ImportError(
-        "`playwright` not installed. Please install using `pip install playwright` and run `playwright install`"
-    )
-
 
 class BrowserbaseTools(Toolkit):
     def __init__(
@@ -36,7 +29,13 @@ class BrowserbaseTools(Toolkit):
         Args:
             api_key (str, optional): Browserbase API key.
             project_id (str, optional): Browserbase project ID.
-            base_url (str, optional): Custom Browserbase API endpoint URL (NOT the target website URL). Only use this if you're using a self-hosted Browserbase instance or need to connect to a different region.
+            base_url (str, optional): Custom Browserbase API endpoint URL (NOT the target website URL).
+                Only use this if you're using a self-hosted Browserbase instance or need to connect to a different region.
+            enable_navigate_to (bool): Enable the navigate_to tool. Defaults to True.
+            enable_screenshot (bool): Enable the screenshot tool. Defaults to True.
+            enable_get_page_content (bool): Enable the get_page_content tool. Defaults to True.
+            enable_close_session (bool): Enable the close_session tool. Defaults to True.
+            all (bool): Enable all tools. Defaults to False.
         """
         self.api_key = api_key or getenv("BROWSERBASE_API_KEY")
         if not self.api_key:
@@ -59,23 +58,40 @@ class BrowserbaseTools(Toolkit):
         else:
             self.app = Browserbase(api_key=self.api_key)
 
+        # Sync playwright state
         self._playwright = None
         self._browser = None
         self._page = None
+
+        # Async playwright state
+        self._async_playwright = None
+        self._async_browser = None
+        self._async_page = None
+
+        # Shared session state
         self._session = None
         self._connect_url = None
 
+        # Build tools lists
+        # sync tools: used by agent.run() and agent.print_response()
+        # async tools: used by agent.arun() and agent.aprint_response()
         tools: List[Any] = []
+        async_tools: List[tuple] = []
+
         if all or enable_navigate_to:
             tools.append(self.navigate_to)
+            async_tools.append((self.anavigate_to, "navigate_to"))
         if all or enable_screenshot:
             tools.append(self.screenshot)
+            async_tools.append((self.ascreenshot, "screenshot"))
         if all or enable_get_page_content:
             tools.append(self.get_page_content)
+            async_tools.append((self.aget_page_content, "get_page_content"))
         if all or enable_close_session:
             tools.append(self.close_session)
+            async_tools.append((self.aclose_session, "close_session"))
 
-        super().__init__(name="browserbase_tools", tools=tools, **kwargs)
+        super().__init__(name="browserbase_tools", tools=tools, async_tools=async_tools, **kwargs)
 
     def _ensure_session(self):
         """Ensures a session exists, creating one if needed."""
@@ -91,9 +107,16 @@ class BrowserbaseTools(Toolkit):
 
     def _initialize_browser(self, connect_url: Optional[str] = None):
         """
-        Initialize browser connection if not already initialized.
+        Initialize sync browser connection if not already initialized.
         Use provided connect_url or ensure we have a session with a connect_url
         """
+        try:
+            from playwright.sync_api import sync_playwright  # type: ignore[import-not-found]
+        except ImportError:
+            raise ImportError(
+                "`playwright` not installed. Please install using `pip install playwright` and run `playwright install`"
+            )
+
         if connect_url:
             self._connect_url = connect_url if connect_url else ""  # type: ignore
         elif not self._connect_url:
@@ -107,7 +130,7 @@ class BrowserbaseTools(Toolkit):
             self._page = context.pages[0] or context.new_page()  # type: ignore
 
     def _cleanup(self):
-        """Clean up browser resources."""
+        """Clean up sync browser resources."""
         if self._browser:
             self._browser.close()
             self._browser = None
@@ -186,8 +209,7 @@ class BrowserbaseTools(Toolkit):
 
     def close_session(self) -> str:
         """Closes a browser session.
-        Args:
-            session_id (str, optional): The session ID to close. If not provided, will use the current session.
+
         Returns:
             JSON string with closure status
         """
@@ -207,3 +229,118 @@ class BrowserbaseTools(Toolkit):
             )
         except Exception as e:
             return json.dumps({"status": "warning", "message": f"Cleanup completed with warning: {str(e)}"})
+
+    async def _ainitialize_browser(self, connect_url: Optional[str] = None):
+        """
+        Initialize async browser connection if not already initialized.
+        Use provided connect_url or ensure we have a session with a connect_url
+        """
+        try:
+            from playwright.async_api import async_playwright  # type: ignore[import-not-found]
+        except ImportError:
+            raise ImportError(
+                "`playwright` not installed. Please install using `pip install playwright` and run `playwright install`"
+            )
+
+        if connect_url:
+            self._connect_url = connect_url if connect_url else ""  # type: ignore
+        elif not self._connect_url:
+            self._ensure_session()
+
+        if not self._async_playwright:
+            self._async_playwright = await async_playwright().start()  # type: ignore
+            if self._async_playwright:
+                self._async_browser = await self._async_playwright.chromium.connect_over_cdp(self._connect_url)
+            context = self._async_browser.contexts[0] if self._async_browser else None
+            if context:
+                self._async_page = context.pages[0] if context.pages else await context.new_page()
+
+    async def _acleanup(self):
+        """Clean up async browser resources."""
+        if self._async_browser:
+            await self._async_browser.close()
+            self._async_browser = None
+        if self._async_playwright:
+            await self._async_playwright.stop()
+            self._async_playwright = None
+        self._async_page = None
+
+    async def anavigate_to(self, url: str, connect_url: Optional[str] = None) -> str:
+        """Navigates to a URL asynchronously.
+
+        Args:
+            url (str): The URL to navigate to
+            connect_url (str, optional): The connection URL from an existing session
+
+        Returns:
+            JSON string with navigation status
+        """
+        try:
+            await self._ainitialize_browser(connect_url)
+            if self._async_page:
+                await self._async_page.goto(url, wait_until="networkidle")
+            title = await self._async_page.title() if self._async_page else ""
+            result = {"status": "complete", "title": title, "url": url}
+            return json.dumps(result)
+        except Exception as e:
+            await self._acleanup()
+            raise e
+
+    async def ascreenshot(self, path: str, full_page: bool = True, connect_url: Optional[str] = None) -> str:
+        """Takes a screenshot of the current page asynchronously.
+
+        Args:
+            path (str): Where to save the screenshot
+            full_page (bool): Whether to capture the full page
+            connect_url (str, optional): The connection URL from an existing session
+
+        Returns:
+            JSON string confirming screenshot was saved
+        """
+        try:
+            await self._ainitialize_browser(connect_url)
+            if self._async_page:
+                await self._async_page.screenshot(path=path, full_page=full_page)
+            return json.dumps({"status": "success", "path": path})
+        except Exception as e:
+            await self._acleanup()
+            raise e
+
+    async def aget_page_content(self, connect_url: Optional[str] = None) -> str:
+        """Gets the HTML content of the current page asynchronously.
+
+        Args:
+            connect_url (str, optional): The connection URL from an existing session
+
+        Returns:
+            The page HTML content
+        """
+        try:
+            await self._ainitialize_browser(connect_url)
+            return await self._async_page.content() if self._async_page else ""
+        except Exception as e:
+            await self._acleanup()
+            raise e
+
+    async def aclose_session(self) -> str:
+        """Closes a browser session asynchronously.
+
+        Returns:
+            JSON string with closure status
+        """
+        try:
+            # First cleanup our local browser resources
+            await self._acleanup()
+
+            # Reset session state
+            self._session = None
+            self._connect_url = None
+
+            return json.dumps(
+                {
+                    "status": "closed",
+                    "message": "Browser resources cleaned up. Session will auto-close if not already closed.",
+                }
+            )
+        except Exception as e:
+            return json.dumps({"status": "warning", "message": f"Cleanup completed with warning: {str(e)}"})

agno/tools/function.py

@@ -1139,10 +1139,15 @@ class FunctionCall(BaseModel):
                 else:
                     result = self.function.entrypoint(**entrypoint_args, **self.arguments)
 
+                # Handle both sync and async entrypoints
                 if isasyncgenfunction(self.function.entrypoint):
                     self.result = result  # Store async generator directly
+                elif iscoroutinefunction(self.function.entrypoint):
+                    self.result = await result  # Await coroutine result
+                elif isgeneratorfunction(self.function.entrypoint):
+                    self.result = result  # Store sync generator directly
                 else:
-                    self.result = await result
+                    self.result = result  # Sync function, result is already computed
 
             # Only cache if not a generator
             if self.function.cache_results and not (isgenerator(self.result) or isasyncgen(self.result)):

agno/tools/mcp/mcp.py

@@ -127,6 +127,7 @@ class MCPTools(Toolkit):
 
         self.transport = transport
 
+        self.header_provider = None
         if self._is_valid_header_provider(header_provider):
             self.header_provider = header_provider