agno 2.3.14__tar.gz → 2.3.15__tar.gz

{agno-2.3.14 → agno-2.3.15}/PKG-INFO

@@ -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 → agno-2.3.15}/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-2.3.14 → agno-2.3.15}/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-2.3.14 → agno-2.3.15}/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-2.3.14 → agno-2.3.15}/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-2.3.14 → agno-2.3.15}/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-2.3.14 → agno-2.3.15}/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-2.3.14 → agno-2.3.15}/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-2.3.14 → agno-2.3.15}/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-2.3.15/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-2.3.14 → agno-2.3.15}/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-2.3.14 → agno-2.3.15}/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-2.3.14 → agno-2.3.15}/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-2.3.14 → agno-2.3.15}/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-2.3.14 → agno-2.3.15}/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: