agno 2.3.14__py3-none-any.whl → 2.3.15__py3-none-any.whl

agno/agent/agent.py

@@ -131,6 +131,7 @@ from agno.utils.events import (
     create_session_summary_completed_event,
     create_session_summary_started_event,
     create_tool_call_completed_event,
+    create_tool_call_error_event,
     create_tool_call_started_event,
     handle_event,
 )
@@ -2304,7 +2305,7 @@ class Agent:
         cultural_knowledge_task = None
 
         # 1. Read or create session. Reads from the database if provided.
-        agent_session = self._read_or_create_session(session_id=session_id, user_id=user_id)
+        agent_session = await self._aread_or_create_session(session_id=session_id, user_id=user_id)
 
         # Set up retry logic
         num_attempts = self.retries + 1
@@ -4946,6 +4947,15 @@ class Agent:
                             events_to_skip=self.events_to_skip,  # type: ignore
                             store_events=self.store_events,
                         )
+                        if tool.tool_call_error:
+                            yield handle_event(  # type: ignore
+                                create_tool_call_error_event(
+                                    from_run_response=run_response, tool=tool, error=str(tool.result)
+                                ),
+                                run_response,
+                                events_to_skip=self.events_to_skip,  # type: ignore
+                                store_events=self.store_events,
+                            )
 
         if len(function_call_results) > 0:
             run_messages.messages.extend(function_call_results)
@@ -5003,6 +5013,15 @@ class Agent:
                             events_to_skip=self.events_to_skip,  # type: ignore
                             store_events=self.store_events,
                         )
+                        if tool.tool_call_error:
+                            yield handle_event(  # type: ignore
+                                create_tool_call_error_event(
+                                    from_run_response=run_response, tool=tool, error=str(tool.result)
+                                ),
+                                run_response,
+                                events_to_skip=self.events_to_skip,  # type: ignore
+                                store_events=self.store_events,
+                            )
         if len(function_call_results) > 0:
             run_messages.messages.extend(function_call_results)
 
@@ -5756,6 +5775,15 @@ class Agent:
                                 events_to_skip=self.events_to_skip,  # type: ignore
                                 store_events=self.store_events,
                             )
+                            if tool_call.tool_call_error:
+                                yield handle_event(  # type: ignore
+                                    create_tool_call_error_event(
+                                        from_run_response=run_response, tool=tool_call, error=str(tool_call.result)
+                                    ),
+                                    run_response,
+                                    events_to_skip=self.events_to_skip,  # type: ignore
+                                    store_events=self.store_events,
+                                )
 
                 if stream_events:
                     if reasoning_step is not None:

agno/db/migrations/manager.py

@@ -66,13 +66,13 @@ class MigrationManager:
                 current_version = packaging_version.parse(self.db.get_latest_schema_version(table_name))
 
             if current_version is None:
-                log_warning(f"Skipping up migration: No version found for table {table_name}.")
+                log_info(f"Skipping migration: No version found for table {table_name}.")
                 continue
 
             # If the target version is less or equal to the current version, no migrations needed
             if _target_version <= current_version and not force:
-                log_warning(
-                    f"Skipping up migration: the version of table '{table_name}' ({current_version}) is less or equal to the target version ({_target_version})."
+                log_info(
+                    f"Skipping migration: the version of table '{table_name}' ({current_version}) is less or equal to the target version ({_target_version})."
                 )
                 continue
 

agno/models/anthropic/claude.py

@@ -102,8 +102,8 @@ class Claude(Model):
         # Claude Sonnet 4.x family (versions before 4.5)
         "claude-sonnet-4-20250514",
         "claude-sonnet-4",
-        # Claude Opus 4.x family (versions before 4.1)
-        # (Add any Opus 4.x models released before 4.1 if they exist)
+        # Claude Opus 4.x family (versions before 4.1 and 4.5)
+        # (Add any Opus 4.x models released before 4.1/4.5 if they exist)
     }
 
     id: str = "claude-sonnet-4-5-20250929"
@@ -191,7 +191,9 @@ class Claude(Model):
             return False
         if self.id.startswith("claude-sonnet-4-") and not self.id.startswith("claude-sonnet-4-5"):
             return False
-        if self.id.startswith("claude-opus-4-") and not self.id.startswith("claude-opus-4-1"):
+        if self.id.startswith("claude-opus-4-") and not (
+            self.id.startswith("claude-opus-4-1") or self.id.startswith("claude-opus-4-5")
+        ):
             return False
 
         return True

agno/models/metrics.py

@@ -13,6 +13,10 @@ class Metrics:
     output_tokens: int = 0
     total_tokens: int = 0
 
+    # Cost of the run
+    # Currently only supported by some providers
+    cost: Optional[float] = None
+
     # Audio token usage
     audio_input_tokens: int = 0
     audio_output_tokens: int = 0
@@ -43,6 +47,7 @@ class Metrics:
         metrics_dict = asdict(self)
         # Remove the timer util if present
         metrics_dict.pop("timer", None)
+        # Remove any None, 0, or empty dict values
         metrics_dict = {
             k: v
             for k, v in metrics_dict.items()
@@ -65,6 +70,13 @@ class Metrics:
             reasoning_tokens=self.reasoning_tokens + other.reasoning_tokens,
         )
 
+        if self.cost is not None and other.cost is not None:
+            result.cost = self.cost + other.cost
+        elif self.cost is not None:
+            result.cost = self.cost
+        elif other.cost is not None:
+            result.cost = other.cost
+
         # Handle provider_metrics
         if self.provider_metrics or other.provider_metrics:
             result.provider_metrics = {}

agno/models/openai/chat.py

@@ -945,4 +945,6 @@ class OpenAIChat(Model):
             metrics.audio_output_tokens = completion_tokens_details.audio_tokens or 0
             metrics.reasoning_tokens = completion_tokens_details.reasoning_tokens or 0
 
+        metrics.cost = getattr(response_usage, "cost", None)
+
         return metrics

agno/os/app.py

@@ -34,6 +34,7 @@ from agno.os.config import (
 from agno.os.interfaces.base import BaseInterface
 from agno.os.router import get_base_router
 from agno.os.routers.agents import get_agent_router
+from agno.os.routers.database import get_database_router
 from agno.os.routers.evals import get_eval_router
 from agno.os.routers.health import get_health_router
 from agno.os.routers.home import get_home_router
@@ -574,6 +575,7 @@ class AgentOS:
             get_metrics_router(dbs=self.dbs),
             get_knowledge_router(knowledge_instances=self.knowledge_instances),
             get_traces_router(dbs=self.dbs),
+            get_database_router(self, settings=self.settings),
         ]
 
         for router in routers:
@@ -614,6 +616,18 @@ class AgentOS:
 
         # Add JWT middleware if authorization is enabled
         if self.authorization:
+            # Set authorization_enabled flag on settings so security key validation is skipped
+            self.settings.authorization_enabled = True
+
+            jwt_configured = bool(getenv("JWT_VERIFICATION_KEY") or getenv("JWT_JWKS_FILE"))
+            security_key_set = bool(self.settings.os_security_key)
+            if jwt_configured and security_key_set:
+                log_warning(
+                    "Both JWT configuration (JWT_VERIFICATION_KEY or JWT_JWKS_FILE) and OS_SECURITY_KEY are set. "
+                    "With authorization=True, only JWT authorization will be used. "
+                    "Consider removing OS_SECURITY_KEY from your environment."
+                )
+
             self._add_jwt_middleware(fastapi_app)
 
         return fastapi_app
@@ -1033,8 +1047,12 @@ class AgentOS:
             Align.center(f"[bold cyan]{public_endpoint}[/bold cyan]"),
             Align.center(f"\n\n[bold dark_orange]OS running on:[/bold dark_orange] http://{host}:{port}"),
         ]
-        if bool(self.settings.os_security_key):
-            panel_group.append(Align.center("\n\n[bold chartreuse3]:lock: Security Enabled[/bold chartreuse3]"))
+        if self.authorization:
+            panel_group.append(
+                Align.center("\n\n[bold chartreuse3]:lock: JWT Authorization Enabled[/bold chartreuse3]")
+            )
+        elif bool(self.settings.os_security_key):
+            panel_group.append(Align.center("\n\n[bold chartreuse3]:lock: Security Key Enabled[/bold chartreuse3]"))
 
         console = Console()
         console.print(

agno/os/auth.py

@@ -1,3 +1,4 @@
+from os import getenv
 from typing import List, Set
 
 from fastapi import Depends, HTTPException, Request
@@ -10,18 +11,43 @@ from agno.os.settings import AgnoAPISettings
 security = HTTPBearer(auto_error=False)
 
 
+def _is_jwt_configured() -> bool:
+    """Check if JWT authentication is configured via environment variables.
+
+    This covers cases where JWT middleware is set up manually (not via authorization=True).
+    """
+    return bool(getenv("JWT_VERIFICATION_KEY") or getenv("JWT_JWKS_FILE"))
+
+
 def get_authentication_dependency(settings: AgnoAPISettings):
     """
     Create an authentication dependency function for FastAPI routes.
 
+    This handles security key authentication (OS_SECURITY_KEY).
+    When JWT authorization is enabled (via authorization=True, JWT environment variables,
+    or manually added JWT middleware), this dependency is skipped as JWT middleware
+    handles authentication.
+
     Args:
-        settings: The API settings containing the security key
+        settings: The API settings containing the security key and authorization flag
 
     Returns:
         A dependency function that can be used with FastAPI's Depends()
     """
 
-    async def auth_dependency(credentials: HTTPAuthorizationCredentials = Depends(security)) -> bool:
+    async def auth_dependency(request: Request, credentials: HTTPAuthorizationCredentials = Depends(security)) -> bool:
+        # If JWT authorization is enabled via settings (authorization=True on AgentOS)
+        if settings and settings.authorization_enabled:
+            return True
+
+        # Check if JWT middleware has already handled authentication
+        if getattr(request.state, "authenticated", False):
+            return True
+
+        # Also skip if JWT is configured via environment variables
+        if _is_jwt_configured():
+            return True
+
         # If no security key is set, skip authentication entirely
         if not settings or not settings.os_security_key:
             return True
@@ -45,13 +71,24 @@ def validate_websocket_token(token: str, settings: AgnoAPISettings) -> bool:
     """
     Validate a bearer token for WebSocket authentication (legacy os_security_key method).
 
+    When JWT authorization is enabled (via authorization=True or JWT environment variables),
+    this validation is skipped as JWT middleware handles authentication.
+
     Args:
         token: The bearer token to validate
-        settings: The API settings containing the security key
+        settings: The API settings containing the security key and authorization flag
 
     Returns:
         True if the token is valid or authentication is disabled, False otherwise
     """
+    # If JWT authorization is enabled, skip security key validation
+    if settings and settings.authorization_enabled:
+        return True
+
+    # Also skip if JWT is configured via environment variables (manual JWT middleware setup)
+    if _is_jwt_configured():
+        return True
+
     # If no security key is set, skip authentication entirely
     if not settings or not settings.os_security_key:
         return True

agno/os/router.py

@@ -1,16 +1,11 @@
-from typing import TYPE_CHECKING, List, Optional, Union, cast
+from typing import TYPE_CHECKING, List, Union, cast
 
 from fastapi import (
     APIRouter,
     Depends,
-    HTTPException,
 )
-from fastapi.responses import JSONResponse
-from packaging import version
 
 from agno.agent.agent import Agent
-from agno.db.base import AsyncBaseDb
-from agno.db.migrations.manager import MigrationManager
 from agno.os.auth import get_authentication_dependency
 from agno.os.schema import (
     AgentSummaryResponse,
@@ -26,9 +21,6 @@ from agno.os.schema import (
     WorkflowSummaryResponse,
 )
 from agno.os.settings import AgnoAPISettings
-from agno.os.utils import (
-    get_db,
-)
 from agno.team.team import Team
 
 if TYPE_CHECKING:
@@ -207,52 +199,4 @@ def get_base_router(
 
         return list(unique_models.values())
 
-    # -- Database Migration routes ---
-    @router.post(
-        "/databases/{db_id}/migrate",
-        tags=["Database"],
-        operation_id="migrate_database",
-        summary="Migrate Database",
-        description=(
-            "Migrate the given database schema to the given target version. "
-            "If a target version is not provided, the database will be migrated to the latest version. "
-        ),
-        responses={
-            200: {
-                "description": "Database migrated successfully",
-                "content": {
-                    "application/json": {
-                        "example": {"message": "Database migrated successfully to version 3.0.0"},
-                    }
-                },
-            },
-            404: {"description": "Database not found", "model": NotFoundResponse},
-            500: {"description": "Failed to migrate database", "model": InternalServerErrorResponse},
-        },
-    )
-    async def migrate_database(db_id: str, target_version: Optional[str] = None):
-        db = await get_db(os.dbs, db_id)
-        if not db:
-            raise HTTPException(status_code=404, detail="Database not found")
-
-        if target_version:
-            # Use the session table as proxy for the database schema version
-            if isinstance(db, AsyncBaseDb):
-                current_version = await db.get_latest_schema_version(db.session_table_name)
-            else:
-                current_version = db.get_latest_schema_version(db.session_table_name)
-
-            if version.parse(target_version) > version.parse(current_version):  # type: ignore
-                MigrationManager(db).up(target_version)  # type: ignore
-            else:
-                MigrationManager(db).down(target_version)  # type: ignore
-
-        # If the target version is not provided, migrate to the latest version
-        else:
-            MigrationManager(db).up()  # type: ignore
-
-        return JSONResponse(
-            content={"message": f"Database migrated successfully to version {target_version}"}, status_code=200
-        )
-
     return router

agno/os/routers/database.py

@@ -0,0 +1,150 @@
+from typing import TYPE_CHECKING, Optional
+
+from fastapi import (
+    APIRouter,
+    Depends,
+    HTTPException,
+)
+from fastapi.responses import JSONResponse
+from packaging import version
+
+from agno.db.base import AsyncBaseDb
+from agno.db.migrations.manager import MigrationManager
+from agno.os.auth import get_authentication_dependency
+from agno.os.schema import (
+    BadRequestResponse,
+    InternalServerErrorResponse,
+    NotFoundResponse,
+    UnauthenticatedResponse,
+    ValidationErrorResponse,
+)
+from agno.os.settings import AgnoAPISettings
+from agno.os.utils import (
+    get_db,
+)
+
+if TYPE_CHECKING:
+    from agno.os.app import AgentOS
+
+
+def get_database_router(
+    os: "AgentOS",
+    settings: AgnoAPISettings = AgnoAPISettings(),
+) -> APIRouter:
+    """Create the database router with comprehensive OpenAPI documentation."""
+    router = APIRouter(
+        dependencies=[Depends(get_authentication_dependency(settings))],
+        responses={
+            400: {"description": "Bad Request", "model": BadRequestResponse},
+            401: {"description": "Unauthorized", "model": UnauthenticatedResponse},
+            404: {"description": "Not Found", "model": NotFoundResponse},
+            422: {"description": "Validation Error", "model": ValidationErrorResponse},
+            500: {"description": "Internal Server Error", "model": InternalServerErrorResponse},
+        },
+    )
+
+    async def _migrate_single_db(db, target_version: Optional[str] = None) -> None:
+        """Migrate a single database."""
+        if target_version:
+            # Use the session table as proxy for the database schema version
+            if isinstance(db, AsyncBaseDb):
+                current_version = await db.get_latest_schema_version(db.session_table_name)
+            else:
+                current_version = db.get_latest_schema_version(db.session_table_name)
+
+            if version.parse(target_version) > version.parse(current_version):  # type: ignore
+                await MigrationManager(db).up(target_version)  # type: ignore
+            else:
+                await MigrationManager(db).down(target_version)  # type: ignore
+        else:
+            # If the target version is not provided, migrate to the latest version
+            await MigrationManager(db).up()  # type: ignore
+
+    @router.post(
+        "/databases/all/migrate",
+        tags=["Database"],
+        operation_id="migrate_all_databases",
+        summary="Migrate All Databases",
+        description=(
+            "Migrate all database schemas to the given target version. "
+            "If a target version is not provided, all databases will be migrated to the latest version."
+        ),
+        responses={
+            200: {
+                "description": "All databases migrated successfully",
+                "content": {
+                    "application/json": {
+                        "example": {"message": "All databases migrated successfully to version 3.0.0"},
+                    }
+                },
+            },
+            500: {"description": "Failed to migrate databases", "model": InternalServerErrorResponse},
+        },
+    )
+    async def migrate_all_databases(target_version: Optional[str] = None):
+        """Migrate all databases."""
+        all_dbs = {db.id: db for db_id, dbs in os.dbs.items() for db in dbs}
+        failed_dbs: dict[str, str] = {}
+
+        for db_id, db in all_dbs.items():
+            try:
+                await _migrate_single_db(db, target_version)
+            except Exception as e:
+                failed_dbs[db_id] = str(e)
+
+        version_msg = f"version {target_version}" if target_version else "latest version"
+        migrated_count = len(all_dbs) - len(failed_dbs)
+
+        if failed_dbs:
+            return JSONResponse(
+                content={
+                    "message": f"Migrated {migrated_count}/{len(all_dbs)} databases to {version_msg}",
+                    "failed": failed_dbs,
+                },
+                status_code=207,  # Multi-Status
+            )
+
+        return JSONResponse(
+            content={"message": f"All databases migrated successfully to {version_msg}"}, status_code=200
+        )
+
+    @router.post(
+        "/databases/{db_id}/migrate",
+        tags=["Database"],
+        operation_id="migrate_database",
+        summary="Migrate Database",
+        description=(
+            "Migrate the given database schema to the given target version. "
+            "If a target version is not provided, the database will be migrated to the latest version."
+        ),
+        responses={
+            200: {
+                "description": "Database migrated successfully",
+                "content": {
+                    "application/json": {
+                        "example": {"message": "Database migrated successfully to version 3.0.0"},
+                    }
+                },
+            },
+            404: {"description": "Database not found", "model": NotFoundResponse},
+            500: {"description": "Failed to migrate database", "model": InternalServerErrorResponse},
+        },
+    )
+    async def migrate_database(db_id: str, target_version: Optional[str] = None):
+        db = await get_db(os.dbs, db_id)
+        if not db:
+            raise HTTPException(status_code=404, detail="Database not found")
+
+        try:
+            await _migrate_single_db(db, target_version)
+
+            version_msg = f"version {target_version}" if target_version else "latest version"
+            return JSONResponse(
+                content={"message": f"Database migrated successfully to {version_msg}"}, status_code=200
+            )
+        except HTTPException:
+            raise
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to migrate database: {str(e)}")
+
+    return router

agno/os/settings.py

@@ -20,6 +20,9 @@ class AgnoAPISettings(BaseSettings):
     # Authentication settings
     os_security_key: Optional[str] = Field(default=None, description="Bearer token for API authentication")
 
+    # Authorization flag - when True, JWT middleware handles auth and security key validation is skipped
+    authorization_enabled: bool = Field(default=False, description="Whether JWT authorization is enabled")
+
     # Cors origin list to allow requests from.
     # This list is set using the set_cors_origin_list validator
     cors_origin_list: Optional[List[str]] = Field(default=None, validate_default=True)

agno/run/agent.py

@@ -153,6 +153,7 @@ class RunEvent(str, Enum):
 
     tool_call_started = "ToolCallStarted"
     tool_call_completed = "ToolCallCompleted"
+    tool_call_error = "ToolCallError"
 
     reasoning_started = "ReasoningStarted"
     reasoning_step = "ReasoningStep"
@@ -405,6 +406,13 @@ class ToolCallCompletedEvent(BaseAgentRunEvent):
     audio: Optional[List[Audio]] = None  # Audio produced by the tool call
 
 
+@dataclass
+class ToolCallErrorEvent(BaseAgentRunEvent):
+    event: str = RunEvent.tool_call_error.value
+    tool: Optional[ToolExecution] = None
+    error: Optional[str] = None
+
+
 @dataclass
 class ParserModelResponseStartedEvent(BaseAgentRunEvent):
     event: str = RunEvent.parser_model_response_started.value
@@ -459,6 +467,7 @@ RunOutputEvent = Union[
     SessionSummaryCompletedEvent,
     ToolCallStartedEvent,
     ToolCallCompletedEvent,
+    ToolCallErrorEvent,
     ParserModelResponseStartedEvent,
     ParserModelResponseCompletedEvent,
     OutputModelResponseStartedEvent,
@@ -492,6 +501,7 @@ RUN_EVENT_TYPE_REGISTRY = {
     RunEvent.session_summary_completed.value: SessionSummaryCompletedEvent,
     RunEvent.tool_call_started.value: ToolCallStartedEvent,
     RunEvent.tool_call_completed.value: ToolCallCompletedEvent,
+    RunEvent.tool_call_error.value: ToolCallErrorEvent,
     RunEvent.parser_model_response_started.value: ParserModelResponseStartedEvent,
     RunEvent.parser_model_response_completed.value: ParserModelResponseCompletedEvent,
     RunEvent.output_model_response_started.value: OutputModelResponseStartedEvent,

agno/run/base.py

@@ -51,6 +51,7 @@ class BaseRunOutputEvent:
                 "session_summary",
                 "metrics",
                 "run_input",
+                "requirements",
             ]
         }
 
@@ -138,6 +139,9 @@ class BaseRunOutputEvent:
         if hasattr(self, "run_input") and self.run_input is not None:
             _dict["run_input"] = self.run_input.to_dict()
 
+        if hasattr(self, "requirements") and self.requirements is not None:
+            _dict["requirements"] = [req.to_dict() if hasattr(req, "to_dict") else req for req in self.requirements]
+
         return _dict
 
     def to_json(self, separators=(", ", ": "), indent: Optional[int] = 2) -> str:
@@ -219,6 +223,21 @@ class BaseRunOutputEvent:
 
                 data["run_input"] = RunInput.from_dict(run_input)
 
+                # Handle requirements
+
+        # Handle requirements
+        requirements_data = data.pop("requirements", None)
+        if requirements_data is not None:
+            from agno.run.requirement import RunRequirement
+
+            requirements_list: List[RunRequirement] = []
+            for item in requirements_data:
+                if isinstance(item, RunRequirement):
+                    requirements_list.append(item)
+                elif isinstance(item, dict):
+                    requirements_list.append(RunRequirement.from_dict(item))
+            data["requirements"] = requirements_list if requirements_list else None
+
         # Filter data to only include fields that are actually defined in the target class
         from dataclasses import fields
 

agno/run/team.py

@@ -146,6 +146,7 @@ class TeamRunEvent(str, Enum):
 
     tool_call_started = "TeamToolCallStarted"
     tool_call_completed = "TeamToolCallCompleted"
+    tool_call_error = "TeamToolCallError"
 
     reasoning_started = "TeamReasoningStarted"
     reasoning_step = "TeamReasoningStep"
@@ -378,6 +379,13 @@ class ToolCallCompletedEvent(BaseTeamRunEvent):
     audio: Optional[List[Audio]] = None  # Audio produced by the tool call
 
 
+@dataclass
+class ToolCallErrorEvent(BaseTeamRunEvent):
+    event: str = TeamRunEvent.tool_call_error.value
+    tool: Optional[ToolExecution] = None
+    error: Optional[str] = None
+
+
 @dataclass
 class ParserModelResponseStartedEvent(BaseTeamRunEvent):
     event: str = TeamRunEvent.parser_model_response_started.value
@@ -428,6 +436,7 @@ TeamRunOutputEvent = Union[
     SessionSummaryCompletedEvent,
     ToolCallStartedEvent,
     ToolCallCompletedEvent,
+    ToolCallErrorEvent,
     ParserModelResponseStartedEvent,
     ParserModelResponseCompletedEvent,
     OutputModelResponseStartedEvent,
@@ -458,6 +467,7 @@ TEAM_RUN_EVENT_TYPE_REGISTRY = {
     TeamRunEvent.session_summary_completed.value: SessionSummaryCompletedEvent,
     TeamRunEvent.tool_call_started.value: ToolCallStartedEvent,
     TeamRunEvent.tool_call_completed.value: ToolCallCompletedEvent,
+    TeamRunEvent.tool_call_error.value: ToolCallErrorEvent,
     TeamRunEvent.parser_model_response_started.value: ParserModelResponseStartedEvent,
     TeamRunEvent.parser_model_response_completed.value: ParserModelResponseCompletedEvent,
     TeamRunEvent.output_model_response_started.value: OutputModelResponseStartedEvent,

agno/team/team.py

@@ -129,6 +129,7 @@ from agno.utils.events import (
     create_team_session_summary_completed_event,
     create_team_session_summary_started_event,
     create_team_tool_call_completed_event,
+    create_team_tool_call_error_event,
     create_team_tool_call_started_event,
     handle_event,
 )
@@ -3831,6 +3832,15 @@ class Team:
                                 events_to_skip=self.events_to_skip,
                                 store_events=self.store_events,
                             )
+                            if tool_call.tool_call_error:
+                                yield handle_event(  # type: ignore
+                                    create_team_tool_call_error_event(
+                                        from_run_response=run_response, tool=tool_call, error=str(tool_call.result)
+                                    ),
+                                    run_response,
+                                    events_to_skip=self.events_to_skip,
+                                    store_events=self.store_events,
+                                )
 
                 if stream_events:
                     if reasoning_step is not None:

agno/tools/toolkit.py

@@ -1,5 +1,5 @@
 from collections import OrderedDict
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional, Sequence, Union
 
 from agno.tools.function import Function
 from agno.utils.log import log_debug, log_warning, logger
@@ -13,7 +13,7 @@ class Toolkit:
     def __init__(
         self,
         name: str = "toolkit",
-        tools: List[Callable] = [],
+        tools: Sequence[Union[Callable[..., Any], Function]] = [],
         instructions: Optional[str] = None,
         add_instructions: bool = False,
         include_tools: Optional[list[str]] = None,
@@ -31,7 +31,7 @@ class Toolkit:
 
         Args:
             name: A descriptive name for the toolkit
-            tools: List of tools to include in the toolkit
+            tools: List of tools to include in the toolkit (can be callables or Function objects from @tool decorator)
             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
@@ -46,7 +46,7 @@ class Toolkit:
             show_result_tools (Optional[List[str]]): List of function names whose results should be shown.
         """
         self.name: str = name
-        self.tools: List[Callable] = tools
+        self.tools: Sequence[Union[Callable[..., Any], Function]] = tools
         self.functions: Dict[str, Function] = OrderedDict()
         self.instructions: Optional[str] = instructions
         self.add_instructions: bool = add_instructions
@@ -58,7 +58,9 @@ class Toolkit:
         self.show_result_tools: list[str] = show_result_tools or []
 
         self._check_tools_filters(
-            available_tools=[tool.__name__ for tool in tools], include_tools=include_tools, exclude_tools=exclude_tools
+            available_tools=[self._get_tool_name(tool) for tool in tools],
+            include_tools=include_tools,
+            exclude_tools=exclude_tools,
         )
 
         self.include_tools = include_tools
@@ -72,6 +74,12 @@ class Toolkit:
         if auto_register and self.tools:
             self._register_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."""
+        if isinstance(tool, Function):
+            return tool.name
+        return tool.__name__
+
     def _check_tools_filters(
         self,
         available_tools: List[str],
@@ -104,22 +112,45 @@ class Toolkit:
                     f"External execution required tool(s) not present in the toolkit: {', '.join(missing_external_execution_required)}"
                 )
 
+        if self.stop_after_tool_call_tools:
+            missing_stop_after_tool_call = set(self.stop_after_tool_call_tools) - set(available_tools)
+            if missing_stop_after_tool_call:
+                log_warning(
+                    f"Stop after tool call tool(s) not present in the toolkit: {', '.join(missing_stop_after_tool_call)}"
+                )
+
+        if self.show_result_tools:
+            missing_show_result = set(self.show_result_tools) - set(available_tools)
+            if missing_show_result:
+                log_warning(f"Show result tool(s) not present in the toolkit: {', '.join(missing_show_result)}")
+
     def _register_tools(self) -> None:
         """Register all tools."""
         for tool in self.tools:
             self.register(tool)
 
-    def register(self, function: Callable[..., Any], name: Optional[str] = None):
+    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).
+        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`
+        3. Create a new Function with the bound method as entrypoint, preserving decorator settings
+
         Args:
-            function: The callable to register
+            function: The callable or Function object to register
             name: Optional custom name for the function
 
         Returns:
             The registered function
         """
         try:
+            # Handle Function objects (from @tool decorator)
+            if isinstance(function, Function):
+                return self._register_decorated_tool(function, name)
+
+            # 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
@@ -140,9 +171,89 @@ class Toolkit:
             self.functions[f.name] = f
             log_debug(f"Function: {f.name} registered with {self.name}")
         except Exception as e:
-            logger.warning(f"Failed to create Function for: {function.__name__}")
+            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:
+        """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
+        method as entrypoint. This method creates a bound version of the entrypoint that
+        includes `self`, preserving all decorator settings.
+
+        Args:
+            function: The Function object from @tool decorator
+            name: Optional custom name override
+        """
+        import inspect
+
+        tool_name = name or function.name
+        if self.include_tools is not None and len(self.include_tools) > 0 and tool_name not in self.include_tools:
+            return
+        if self.exclude_tools is not None and len(self.exclude_tools) > 0 and tool_name in self.exclude_tools:
+            return
+
+        # Get the original entrypoint from the Function
+        if function.entrypoint is None:
+            log_warning(f"Function '{tool_name}' has no entrypoint, skipping registration")
+            return
+
+        original_func = function.entrypoint
+
+        # Check if the function expects 'self' as first argument (i.e., it's an unbound method)
+        sig = inspect.signature(original_func)
+        params = list(sig.parameters.keys())
+
+        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)
+
+                # Preserve function metadata for debugging
+                bound.__name__ = getattr(func, "__name__", tool_name)
+                bound.__doc__ = getattr(func, "__doc__", None)
+                return bound
+
+            bound_method = make_bound_method(original_func, self)
+        else:
+            # Function doesn't expect self (e.g., static method or already bound)
+            bound_method = original_func
+
+        # decorator settings take precedence, then toolkit settings
+        stop_after = function.stop_after_tool_call or tool_name in self.stop_after_tool_call_tools
+        show_result = function.show_result or tool_name in self.show_result_tools or stop_after
+        requires_confirmation = function.requires_confirmation or tool_name in self.requires_confirmation_tools
+        external_execution = function.external_execution or tool_name in self.external_execution_required_tools
+
+        # Create new Function with bound method, preserving decorator settings
+        f = Function(
+            name=tool_name,
+            description=function.description,
+            parameters=function.parameters,
+            strict=function.strict,
+            instructions=function.instructions,
+            add_instructions=function.add_instructions,
+            entrypoint=bound_method,
+            skip_entrypoint_processing=True,  # Parameters already processed by decorator
+            show_result=show_result,
+            stop_after_tool_call=stop_after,
+            pre_hook=function.pre_hook,
+            post_hook=function.post_hook,
+            tool_hooks=function.tool_hooks,
+            requires_confirmation=requires_confirmation,
+            requires_user_input=function.requires_user_input,
+            user_input_fields=function.user_input_fields,
+            user_input_schema=function.user_input_schema,
+            external_execution=external_execution,
+            cache_results=function.cache_results if function.cache_results else self.cache_results,
+            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)")
+
     @property
     def requires_connect(self) -> bool:
         """Whether the toolkit requires connection management."""

agno/utils/events.py

@@ -34,6 +34,7 @@ from agno.run.agent import (
     SessionSummaryCompletedEvent,
     SessionSummaryStartedEvent,
     ToolCallCompletedEvent,
+    ToolCallErrorEvent,
     ToolCallStartedEvent,
 )
 from agno.run.requirement import RunRequirement
@@ -61,6 +62,7 @@ from agno.run.team import SessionSummaryCompletedEvent as TeamSessionSummaryComp
 from agno.run.team import SessionSummaryStartedEvent as TeamSessionSummaryStartedEvent
 from agno.run.team import TeamRunEvent, TeamRunInput, TeamRunOutput, TeamRunOutputEvent
 from agno.run.team import ToolCallCompletedEvent as TeamToolCallCompletedEvent
+from agno.run.team import ToolCallErrorEvent as TeamToolCallErrorEvent
 from agno.run.team import ToolCallStartedEvent as TeamToolCallStartedEvent
 from agno.session.summary import SessionSummary
 
@@ -561,6 +563,32 @@ def create_team_tool_call_completed_event(
     )
 
 
+def create_tool_call_error_event(
+    from_run_response: RunOutput, tool: ToolExecution, error: Optional[str] = None
+) -> ToolCallErrorEvent:
+    return ToolCallErrorEvent(
+        session_id=from_run_response.session_id,
+        agent_id=from_run_response.agent_id,  # type: ignore
+        agent_name=from_run_response.agent_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        tool=tool,
+        error=error,
+    )
+
+
+def create_team_tool_call_error_event(
+    from_run_response: TeamRunOutput, tool: ToolExecution, error: Optional[str] = None
+) -> TeamToolCallErrorEvent:
+    return TeamToolCallErrorEvent(
+        session_id=from_run_response.session_id,
+        team_id=from_run_response.team_id,  # type: ignore
+        team_name=from_run_response.team_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        tool=tool,
+        error=error,
+    )
+
+
 def create_run_output_content_event(
     from_run_response: RunOutput,
     content: Optional[Any] = None,
@@ -738,8 +766,8 @@ def handle_event(
     store_events: bool = False,
 ) -> Union[RunOutputEvent, TeamRunOutputEvent]:
     # We only store events that are not run_response_content events
-    events_to_skip = [event.value for event in events_to_skip] if events_to_skip else []
-    if store_events and event.event not in events_to_skip:
+    _events_to_skip: List[str] = [event.value for event in events_to_skip] if events_to_skip else []
+    if store_events and event.event not in _events_to_skip:
         if run_response.events is None:
             run_response.events = []
         run_response.events.append(event)  # type: ignore

{agno-2.3.14.dist-info → agno-2.3.15.dist-info}/METADATA

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

{agno-2.3.14.dist-info → agno-2.3.15.dist-info}/RECORD

@@ -6,7 +6,7 @@ agno/media.py,sha256=PisfrNwkx2yVOW8p6LXlV237jI06Y6kGjd7wUMk5170,17121
 agno/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agno/table.py,sha256=9hHFnInNsrj0ZKtWjGDP5c6kbmNdtQvDDYT2j2CZJ6o,198
 agno/agent/__init__.py,sha256=s7S3FgsjZxuaabzi8L5n4aSH8IZAiZ7XaNNcySGR-EQ,1051
-agno/agent/agent.py,sha256=RSI3N4A5_wLndzfwR2k_b94urIKsTcYVNejGk4QgWBA,487486
+agno/agent/agent.py,sha256=-uPBEnmf2vV81H9OBJ8ozIsvTUVqgPFQIZCuFgBlRPM,489186
 agno/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agno/api/agent.py,sha256=fKlQ62E_C9Rjd7Zus3Gs3R1RG-IhzFV-ICpkb6SLqYc,932
 agno/api/api.py,sha256=gFhVjxJYkQsw8mBl2fhoStMPGlyJ37DJaqgUOwZVvQI,1021
@@ -55,7 +55,7 @@ agno/db/json/__init__.py,sha256=zyPTmVF9S-OwXCL7FSkrDmunZ_Q14YZO3NYUv1Pa14Y,62
 agno/db/json/json_db.py,sha256=YJYPJfLVldDZXx5pmflg_O8OfaXBbBNLOJHGE5qEuOY,69793
 agno/db/json/utils.py,sha256=ywD72LhxKl6yfmENKlOgCkw5W_XJ-oeOPSVvjsNnOy8,8062
 agno/db/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-agno/db/migrations/manager.py,sha256=D7-qgN0KxP_tLAhJw_1uPNCtxpiK-6r-S1Gg5r8AD0k,9647
+agno/db/migrations/manager.py,sha256=x7jH5UBFFqoUbFETBM94pgNSt9L-rRVlNvUyqHVQ8GM,9635
 agno/db/migrations/v1_to_v2.py,sha256=gj8deaEWUxOr0qJyMfjOpV3LxEh-otOSOxDckeUq0qU,24938
 agno/db/migrations/versions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agno/db/migrations/versions/v2_3_0.py,sha256=WikuOtgQs_Tq8o3JndCMG6HAMzKvz4GVth9V5V5RuvE,35161
@@ -187,13 +187,13 @@ agno/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agno/models/base.py,sha256=7zGj7QUitUUdWD_xxJQIpgdLNbghnrIFDqem4d6DJ2Q,122737
 agno/models/defaults.py,sha256=1_fe4-ZbNriE8BgqxVRVi4KGzEYxYKYsz4hn6CZNEEM,40
 agno/models/message.py,sha256=5bZOFdZuhsQw06nNppvFJq-JGI4lqQt4sVhdjfEFBZM,19976
-agno/models/metrics.py,sha256=81IILXZwGmOTiWK003bi5mg4bM1f4LCWbwyamjFzp18,4500
+agno/models/metrics.py,sha256=bQJ5DMoFcrb2EyA2VUm4u9HVGbgTKO5F1o2A_t_7hqI,4913
 agno/models/response.py,sha256=uwSw2wKm5U1ZJ1R-8dMWV1I7TgFlKTJGOFq73WExO6s,7110
 agno/models/utils.py,sha256=jxAIIG2y7KBypwFlc87GzFnvogRpGLfd-wwr6KXZIj8,7269
 agno/models/aimlapi/__init__.py,sha256=XQcFRvt4qJ8ol9nCC0XKEkVEDivdNf3nZNoJZMZ5m8M,78
 agno/models/aimlapi/aimlapi.py,sha256=ELPv8RuEc6qUq4JxWEJVRITsK71rzUxw6_cP3Zd8Vz0,2179
 agno/models/anthropic/__init__.py,sha256=nbReX3p17JCwfrMDR9hR7-OaEFZm80I7dng93dl-Fhw,77
-agno/models/anthropic/claude.py,sha256=R2Jfh7onRcvU_ZQx7p--QDaIrOEKsv_1eKGFu0J11VY,49224
+agno/models/anthropic/claude.py,sha256=eUv6bml5n_tWCwE4Sr6Yg4eWyo5VDbRq0jO5Eqeeu9k,49301
 agno/models/aws/__init__.py,sha256=TbcwQwv9A7KjqBM5RQBR8x46GvyyCxbBCjwkpjfVGKE,352
 agno/models/aws/bedrock.py,sha256=6qMlxwpnGTBz5T5aIpMrKg5hmRJJJ50D7IrdkW8xLYw,32156
 agno/models/aws/claude.py,sha256=d_vwWtZZw3KHOOTLrPV_C7IWozIMxNafAHmxesyg1mk,9097
@@ -249,7 +249,7 @@ agno/models/nvidia/nvidia.py,sha256=Q81Ey-IJFefOmlrjbBgwNXZ2ARey-j6pXPJHItaE8uY,
 agno/models/ollama/__init__.py,sha256=TIhwxG7ek3eyfoKTLoZQXwdgzcIngYKjbjSlkf2gkWE,72
 agno/models/ollama/chat.py,sha256=Szc8rEWRvQ2CW50V5xAuccX4Ozc1BAV9wUPbFJhY_J8,16862
 agno/models/openai/__init__.py,sha256=OssVgQRpsriU6aJZ3lIp_jFuqvX6y78L4Fd3uTlmI3E,225
-agno/models/openai/chat.py,sha256=zAAN9LJL29G_wWVxw-xOlngFqI7byHZzS910Wn04YT0,41529
+agno/models/openai/chat.py,sha256=gMh6meevEdQF8HEyHLp6O3Wpxwz84boISPUnLK-p_kE,41591
 agno/models/openai/like.py,sha256=wmw9PfAVqluBs4MMY73dgjelKn1yl5JDKyCRvaNFjFw,745
 agno/models/openai/responses.py,sha256=-jy7ch2qH69C_8zcW1CPJA8ZXhr80sG_1kZfqv_dHzs,48769
 agno/models/openrouter/__init__.py,sha256=ZpZhNyy_EGSXp58uC9e2iyjnxBctql7GaY8rUG-599I,90
@@ -275,14 +275,14 @@ agno/models/vllm/vllm.py,sha256=qaWgYcmegJZL52ZjmuIoryBpZ9LpOvYHFY-AYxVirA4,2806
 agno/models/xai/__init__.py,sha256=ukcCxnCHxTtkJNA2bAMTX4MhCv1wJcbiq8ZIfYczIxs,55
 agno/models/xai/xai.py,sha256=i7QoRiVdmoQ1E8Zw_e60qQgF85geZXWRPtEKioIInSU,4796
 agno/os/__init__.py,sha256=h8oQu7vhD5RZf09jkyM_Kt1Kdq_d5kFB9gJju8QPwcY,55
-agno/os/app.py,sha256=38L2yZHM-cV-NWtinqqPNvPiTGqugljffhKH4avX7TY,41587
-agno/os/auth.py,sha256=2OxOJYTtYk31YFv5z95LppTuvrp902_HEb9lj2qjEyI,8958
+agno/os/app.py,sha256=nng6zNVrj3LhuewYBsnLiBs9KAXeqF11i_rN5kKn6Gc,42586
+agno/os/auth.py,sha256=UawDRapLfZQux-xSOQX00oID0Hags75xNh7Jy6c06eU,10496
 agno/os/config.py,sha256=z0wNd576_qsQGsQWsMRIZzjknDVEPlKWF_pHE6VBUyY,3538
 agno/os/mcp.py,sha256=LrCZ6xQ6RAJfnxHYGgHQStanWN4u2bjzcxHjD_cZxBk,10362
-agno/os/router.py,sha256=KI4nchX-ZDWjRg4Dvv5-uWv7d86I9WBQyXQSCMI52u0,10441
+agno/os/router.py,sha256=uv9BrWmwzRCE_sJL5n-jFgag9eDksAfDoIv4VI9Z3iQ,8131
 agno/os/schema.py,sha256=qLkiCbr6IWP6xUGa905CU1dzb5YV5dpZ4qbL1mkVP3g,29376
 agno/os/scopes.py,sha256=gH3Obo618gHKt5h-N1OkWqB4UPl2LZygd7GW7pKzdAc,15696
-agno/os/settings.py,sha256=Cn5_8lZI8Vx1UaUYqs9h6Qp4IMDFn4f3c35uppiaMy4,1343
+agno/os/settings.py,sha256=gS9pN1w21wsa5XqDkK-RfQmroAaqoX4KZBfRuhUevkM,1556
 agno/os/utils.py,sha256=F2dwWPDBr_1NGlR686ElCsFFQWZAXViqvQdmTMGzDYI,37309
 agno/os/interfaces/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 agno/os/interfaces/base.py,sha256=vXkr1tRjWHTcmBlQFzvQjqURLhObmFtUAx82uij_j48,542
@@ -305,6 +305,7 @@ agno/os/interfaces/whatsapp/whatsapp.py,sha256=tNJncEu_hm0lFOHbjaSoz5-VIKORR_pyW
 agno/os/middleware/__init__.py,sha256=Ai4U-Bj2W17PcwNK4j98V0p9mf1XW-NyL7r3VG-a8Ow,130
 agno/os/middleware/jwt.py,sha256=hq3u4xYN9EowA2cTye7CSUGqB5cxqToLPlzUs4JnJV0,33137
 agno/os/routers/__init__.py,sha256=du4LO9aZwiY1t59VcV9M6wiAfftFFlUZc-YXsTGy9LI,97
+agno/os/routers/database.py,sha256=0oyPQlmzJtqEIHT7RGY1IkhPX9PHFKKfjneHaqcqx-I,5803
 agno/os/routers/health.py,sha256=AO3ec6Xi1wXOwUUFJhEcM45488qu6aZRJTwF2GLz6Ak,992
 agno/os/routers/home.py,sha256=xe8DYJkRgad55qiza0lHt8pUIV5PLSyu2MkybjuPDDE,1708
 agno/os/routers/agents/__init__.py,sha256=nr1H0Mp7NlWPnvu0ccaHVSPHz-lXg43TRMApkUIEXNc,91
@@ -348,12 +349,12 @@ agno/reasoning/openai.py,sha256=omgtpg6y9ki3IiIs8gHfxPzndvg-XQ_whSg6t8WKFJE,8074
 agno/reasoning/step.py,sha256=6DaOb_0DJRz9Yh1w_mxcRaOSVzIQDrj3lQ6rzHLdIwA,1220
 agno/reasoning/vertexai.py,sha256=CCdY-ygLEdQLQuo2D-dYC0aDr4FJ9BqtkCkk2U2Ftfs,6174
 agno/run/__init__.py,sha256=DFjpUomTzHvIDQQE_PUfp4oJM-7Ti8h8a_Fe5Kr8rjM,98
-agno/run/agent.py,sha256=mtJhqKKkHC8O2Huv3P7aUZ_dioCfc9tjrWdl92T1yqM,29474
-agno/run/base.py,sha256=WR3V3HIaIImO7u_o3YQuxAz8yMo_NZy6g3gh0K5TP7k,8946
+agno/run/agent.py,sha256=U678dBfis4W-9r1_YdgqEjo1LhmWJv2YH17CqlB0JvE,29771
+agno/run/base.py,sha256=SqiprPcwBbjVRxSi9zlMqPsN6QDh0UHMvodnRBZnH5c,9814
 agno/run/cancel.py,sha256=yoSj3fnx8D7Gf-fSngVIgd3GOp3tRaDhHH_4QeHDoAk,2667
 agno/run/messages.py,sha256=rAC4CLW-xBA6qFS1BOvcjJ9j_qYf0a7sX1mcdY04zMU,1126
 agno/run/requirement.py,sha256=5M_L-3nKLPDS0tUxTbFNvgXgWfWUyEohQz_3bxNc39M,6817
-agno/run/team.py,sha256=bk5t3hjHIhfj4QWeP1T2VqsHsES284l0Db46XnftI3E,28518
+agno/run/team.py,sha256=mbSt4lCjTVGD6d9C3BmDGC8Lam9Wmvm3Lql6GZEY3hs,28826
 agno/run/workflow.py,sha256=cHH_ArV_Wws__8ug9Dwy3OVu7G2ND_K9E1PNdzk7CZo,25100
 agno/session/__init__.py,sha256=p6eqzWcLSHiMex2yZvkwv2yrFUNdGs21TGMS49xrEC4,376
 agno/session/agent.py,sha256=8vVtwwUC5moGWdRcG99Ik6Ay7gbFRrPPnT1ncOUFQIg,10365
@@ -361,7 +362,7 @@ agno/session/summary.py,sha256=9JnDyQyggckd3zx6L8Q5f-lglZvrFQxvPjGU8gLCgR4,10292
 agno/session/team.py,sha256=J7QIy8oCi2_eWs0ToDs7VHHfeFQI34cF4i1Yx7Tbv_M,13388
 agno/session/workflow.py,sha256=nPHnh1N0SJby5JRjysCUI-kTDCelQMFfqosEnnLzPIg,19690
 agno/team/__init__.py,sha256=toHidBOo5M3n_TIVtIKHgcDbLL9HR-_U-YQYuIt_XtE,847
-agno/team/team.py,sha256=uPQGlx1mDRzR2t3zAo5R-5-6t9IpA0XBnKY7TorxZdc,425401
+agno/team/team.py,sha256=XmCaN96RZnQquJ5ON_2W9uOMLhVYrTZ2wZ4r4vgHHwg,426016
 agno/tools/__init__.py,sha256=jNll2sELhPPbqm5nPeT4_uyzRO2_KRTW-8Or60kioS0,210
 agno/tools/agentql.py,sha256=S82Z9aTNr-E5wnA4fbFs76COljJtiQIjf2grjz3CkHU,4104
 agno/tools/airflow.py,sha256=uf2rOzZpSU64l_qRJ5Raku-R3Gky-uewmYkh6W0-oxg,2610
@@ -459,7 +460,7 @@ agno/tools/tavily.py,sha256=1habkgXXHU8oStWmoZ29DVRBtl-tO-Pss1o9N1MovIU,10464
 agno/tools/telegram.py,sha256=e78EJlh44EmJNnv3FHyxW-sl72GjFYHpF6aGrCjNijc,1523
 agno/tools/todoist.py,sha256=p3TCQ0zAfmrhGIHDExVb8bmY0746UbzAbKHNFJlGggw,8177
 agno/tools/tool_registry.py,sha256=LMKqamTqjbFBD6SAV39PJULPmpfiHwSq6_NQoBxvGl8,85
-agno/tools/toolkit.py,sha256=c_lE_VkB36eeX1b89qr7cCsgx_p3f5fvoSV7WiNbu0E,7586
+agno/tools/toolkit.py,sha256=LkJ-KjpW11hDH6IFTlrE_IQfn7ND3ZVcKrl3AkzJNcg,13281
 agno/tools/trafilatura.py,sha256=AK2Q_0jqwOqL8-0neMI6ZjuUt-w0dGvW-w8zE6FrZVs,14792
 agno/tools/trello.py,sha256=y2fc60ITCIXBOk4TX3w70YjkMvM9SMKsEYpfXOKWtOI,8546
 agno/tools/twilio.py,sha256=XUbUhFJdLxP3nlNx2UdS9aHva-HSIGHD01cHHuE9Rfg,6752
@@ -505,7 +506,7 @@ agno/utils/cryptography.py,sha256=iDR0Oij2A1CS1NNvKBnbGJkBe4IWiBZPnV7Q0skBHPQ,85
 agno/utils/dttm.py,sha256=MwVpm03DY_sR6NArsSBYg7_sBBsYfWMBQcLCfi7Q4rY,1290
 agno/utils/enum.py,sha256=wDHnruIf8cQU-_QdryY9LBugPCrlj-nOabQuEFnmeYM,753
 agno/utils/env.py,sha256=o8OwKhx78vi8MaXPes10mXejmJ13CqAh7ODKMS1pmcM,438
-agno/utils/events.py,sha256=tCrfy6rQs46ZbTvJoMRWJtofbxdq8mVg6ENPG__EqPU,30350
+agno/utils/events.py,sha256=z99rRtxRVax2lcgKxbtDkG03DjlL81_eVKIpT7czmZo,31345
 agno/utils/format_str.py,sha256=Zp9dDGMABUJzulp2bs41JiNv0MqmMX0qPToL7l_Ab1c,376
 agno/utils/functions.py,sha256=eHvGqO2uO63TR-QmmhZy2DEnC0xkAfhBG26z77T7jCo,6306
 agno/utils/gemini.py,sha256=-RrZRk4fKRsNCsFVKqXc1JzZaLU3_vIlzGS-YWbz4Bs,16055
@@ -607,8 +608,8 @@ agno/workflow/step.py,sha256=voTmWWihLKDAMeLgYoie96KLCiVpxPFrZoFHEMhA6QM,75046
 agno/workflow/steps.py,sha256=rbfue2M4qYEkgHueojCY1-cB4i1MFjO-jX6uTxyoKwk,27118
 agno/workflow/types.py,sha256=OJXn4sYQ1VQ1H7UO_BwOO3_6q-OgcDX2XLDw3H4LIx0,20508
 agno/workflow/workflow.py,sha256=ylRulasAlJXDC90BpPaFxXNnlO_xcf5LxAbmcTU-Ltg,193481
-agno-2.3.14.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-agno-2.3.14.dist-info/METADATA,sha256=FP7CrMLcCMcVBGwTxaUnBAKoGWjfCba0AsjtsSQVkPA,31588
-agno-2.3.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-agno-2.3.14.dist-info/top_level.txt,sha256=MKyeuVesTyOKIXUhc-d_tPa2Hrh0oTA4LM0izowpx70,5
-agno-2.3.14.dist-info/RECORD,,
+agno-2.3.15.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+agno-2.3.15.dist-info/METADATA,sha256=b8wMpod_FDa0Q7AxuquuiY36XHIQojsIzFu6zhfj82A,31588
+agno-2.3.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+agno-2.3.15.dist-info/top_level.txt,sha256=MKyeuVesTyOKIXUhc-d_tPa2Hrh0oTA4LM0izowpx70,5
+agno-2.3.15.dist-info/RECORD,,