agno 2.0.0rc1__py3-none-any.whl → 2.0.0rc2__py3-none-any.whl

agno/os/routers/session/session.py

@@ -7,7 +7,10 @@ from agno.db.base import BaseDb, SessionType
 from agno.os.auth import get_authentication_dependency
 from agno.os.schema import (
     AgentSessionDetailSchema,
+    BadRequestResponse,
     DeleteSessionRequest,
+    InternalServerErrorResponse,
+    NotFoundResponse,
     PaginatedResponse,
     PaginationInfo,
     RunSchema,
@@ -15,6 +18,8 @@ from agno.os.schema import (
     SortOrder,
     TeamRunSchema,
     TeamSessionDetailSchema,
+    UnauthenticatedResponse,
+    ValidationErrorResponse,
     WorkflowRunSchema,
     WorkflowSessionDetailSchema,
 )
@@ -25,24 +30,77 @@ logger = logging.getLogger(__name__)
 
 
 def get_session_router(dbs: dict[str, BaseDb], settings: AgnoAPISettings = AgnoAPISettings()) -> APIRouter:
-    session_router = APIRouter(dependencies=[Depends(get_authentication_dependency(settings))], tags=["Sessions"])
+    """Create session router with comprehensive OpenAPI documentation for session management endpoints."""
+    session_router = APIRouter(
+        dependencies=[Depends(get_authentication_dependency(settings))],
+        tags=["Sessions"],
+        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},
+        },
+    )
     return attach_routes(router=session_router, dbs=dbs)
 
 
 def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
     @router.get(
-        "/sessions", response_model=PaginatedResponse[SessionSchema], status_code=200, operation_id="get_sessions"
+        "/sessions",
+        response_model=PaginatedResponse[SessionSchema],
+        status_code=200,
+        operation_id="get_sessions",
+        summary="List Sessions",
+        description=(
+            "Retrieve paginated list of sessions with filtering and sorting options. "
+            "Supports filtering by session type (agent, team, workflow), component, user, and name. "
+            "Sessions represent conversation histories and execution contexts."
+        ),
+        responses={
+            200: {
+                "description": "Sessions retrieved successfully",
+                "content": {
+                    "application/json": {
+                        "example": {
+                            "session_example": {
+                                "summary": "Example session response",
+                                "value": {
+                                    "data": [
+                                        {
+                                            "session_id": "6f6cfbfd-9643-479a-ae47-b8f32eb4d710",
+                                            "session_name": "What tools do you have?",
+                                            "session_state": {},
+                                            "created_at": "2025-09-05T16:02:09Z",
+                                            "updated_at": "2025-09-05T16:02:09Z",
+                                        }
+                                    ]
+                                },
+                            }
+                        }
+                    }
+                },
+            },
+            400: {"description": "Invalid session type or filter parameters", "model": BadRequestResponse},
+            422: {"description": "Validation error in query parameters", "model": ValidationErrorResponse},
+        },
     )
     async def get_sessions(
-        session_type: SessionType = Query(default=SessionType.AGENT, alias="type"),
-        component_id: Optional[str] = Query(default=None, description="Filter sessions by component ID"),
+        session_type: SessionType = Query(
+            default=SessionType.AGENT,
+            alias="type",
+            description="Type of sessions to retrieve (agent, team, or workflow)",
+        ),
+        component_id: Optional[str] = Query(
+            default=None, description="Filter sessions by component ID (agent/team/workflow ID)"
+        ),
         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"),
-        limit: Optional[int] = Query(default=20, description="Number of sessions to return"),
-        page: Optional[int] = Query(default=1, description="Page number"),
-        sort_by: Optional[str] = Query(default="created_at", description="Field to sort by"),
+        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"),
+        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="The ID of the database to use"),
+        db_id: Optional[str] = Query(default=None, description="Database ID to query sessions from"),
     ) -> PaginatedResponse[SessionSchema]:
         db = get_db(dbs, db_id)
         sessions, total_count = db.get_sessions(
@@ -72,11 +130,94 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
         response_model=Union[AgentSessionDetailSchema, TeamSessionDetailSchema, WorkflowSessionDetailSchema],
         status_code=200,
         operation_id="get_session_by_id",
+        summary="Get Session by ID",
+        description=(
+            "Retrieve detailed information about a specific session including metadata, configuration, "
+            "and run history. Response schema varies based on session type (agent, team, or workflow)."
+        ),
+        responses={
+            200: {
+                "description": "Session details retrieved successfully",
+                "content": {
+                    "application/json": {
+                        "examples": {
+                            "agent_session_example": {
+                                "summary": "Example agent session response",
+                                "value": {
+                                    "user_id": "123",
+                                    "agent_session_id": "6f6cfbfd-9643-479a-ae47-b8f32eb4d710",
+                                    "session_id": "6f6cfbfd-9643-479a-ae47-b8f32eb4d710",
+                                    "session_name": "What tools do you have?",
+                                    "session_summary": {
+                                        "summary": "The user and assistant engaged in a conversation about the tools the agent has available.",
+                                        "updated_at": "2025-09-05T18:02:12.269392",
+                                    },
+                                    "session_state": {},
+                                    "agent_id": "basic-agent",
+                                    "total_tokens": 160,
+                                    "agent_data": {
+                                        "name": "Basic Agent",
+                                        "agent_id": "basic-agent",
+                                        "model": {"provider": "OpenAI", "name": "OpenAIChat", "id": "gpt-4o"},
+                                    },
+                                    "metrics": {
+                                        "input_tokens": 134,
+                                        "output_tokens": 26,
+                                        "total_tokens": 160,
+                                        "audio_input_tokens": 0,
+                                        "audio_output_tokens": 0,
+                                        "audio_total_tokens": 0,
+                                        "cache_read_tokens": 0,
+                                        "cache_write_tokens": 0,
+                                        "reasoning_tokens": 0,
+                                        "timer": None,
+                                        "time_to_first_token": None,
+                                        "duration": None,
+                                        "provider_metrics": None,
+                                        "additional_metrics": None,
+                                    },
+                                    "chat_history": [
+                                        {
+                                            "content": "<additional_information>\n- Use markdown to format your answers.\n- The current time is 2025-09-05 18:02:09.171627.\n</additional_information>\n\nYou have access to memories from previous interactions with the user that you can use:\n\n<memories_from_previous_interactions>\n- User really likes Digimon and Japan.\n- User really likes Japan.\n- User likes coffee.\n</memories_from_previous_interactions>\n\nNote: this information is from previous interactions and may be updated in this conversation. You should always prefer information from this conversation over the past memories.",
+                                            "from_history": False,
+                                            "stop_after_tool_call": False,
+                                            "role": "system",
+                                            "created_at": 1757088129,
+                                        },
+                                        {
+                                            "content": "What tools do you have?",
+                                            "from_history": False,
+                                            "stop_after_tool_call": False,
+                                            "role": "user",
+                                            "created_at": 1757088129,
+                                        },
+                                        {
+                                            "content": "I don't have access to external tools or the internet. However, I can assist you with a wide range of topics by providing information, answering questions, and offering suggestions based on the knowledge I've been trained on. If there's anything specific you need help with, feel free to ask!",
+                                            "from_history": False,
+                                            "stop_after_tool_call": False,
+                                            "role": "assistant",
+                                            "metrics": {"input_tokens": 134, "output_tokens": 26, "total_tokens": 160},
+                                            "created_at": 1757088129,
+                                        },
+                                    ],
+                                    "created_at": "2025-09-05T16:02:09Z",
+                                    "updated_at": "2025-09-05T16:02:09Z",
+                                },
+                            }
+                        }
+                    }
+                },
+            },
+            404: {"description": "Session not found", "model": NotFoundResponse},
+            422: {"description": "Invalid session type", "model": ValidationErrorResponse},
+        },
     )
     async def get_session_by_id(
-        session_id: str = Path(...),
-        session_type: SessionType = Query(default=SessionType.AGENT, description="Session type filter", alias="type"),
-        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+        session_id: str = Path(description="Session ID to retrieve"),
+        session_type: SessionType = Query(
+            default=SessionType.AGENT, description="Session type (agent, team, or workflow)", alias="type"
+        ),
+        db_id: Optional[str] = Query(default=None, description="Database ID to query session from"),
     ) -> Union[AgentSessionDetailSchema, TeamSessionDetailSchema, WorkflowSessionDetailSchema]:
         db = get_db(dbs, db_id)
         session = db.get_session(session_id=session_id, session_type=session_type)
@@ -95,11 +236,121 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
         response_model=Union[List[RunSchema], List[TeamRunSchema], List[WorkflowRunSchema]],
         status_code=200,
         operation_id="get_session_runs",
+        summary="Get Session Runs",
+        description=(
+            "Retrieve all runs (executions) for a specific session. Runs represent individual "
+            "interactions or executions within a session. Response schema varies based on session type."
+        ),
+        responses={
+            200: {
+                "description": "Session runs retrieved successfully",
+                "content": {
+                    "application/json": {
+                        "examples": {
+                            "completed_run": {
+                                "summary": "Example completed run",
+                                "value": {
+                                    "run_id": "fcdf50f0-7c32-4593-b2ef-68a558774340",
+                                    "agent_session_id": "80056af0-c7a5-4d69-b6a2-c3eba9f040e0",
+                                    "user_id": "",
+                                    "run_input": "Which tools do you have access to?",
+                                    "content": "I don't have access to external tools or the internet. However, I can assist you with a wide range of topics by providing information, answering questions, and offering suggestions based on the knowledge I've been trained on. If there's anything specific you need help with, feel free to ask!",
+                                    "run_response_format": "text",
+                                    "reasoning_content": "",
+                                    "metrics": {
+                                        "input_tokens": 82,
+                                        "output_tokens": 56,
+                                        "total_tokens": 138,
+                                        "time_to_first_token": 0.047505500027909875,
+                                        "duration": 4.840060166025069,
+                                    },
+                                    "messages": [
+                                        {
+                                            "content": "<additional_information>\n- Use markdown to format your answers.\n- The current time is 2025-09-08 17:52:10.101003.\n</additional_information>\n\nYou have the capability to retain memories from previous interactions with the user, but have not had any interactions with the user yet.",
+                                            "from_history": False,
+                                            "stop_after_tool_call": False,
+                                            "role": "system",
+                                            "created_at": 1757346730,
+                                        },
+                                        {
+                                            "content": "Which tools do you have access to?",
+                                            "from_history": False,
+                                            "stop_after_tool_call": False,
+                                            "role": "user",
+                                            "created_at": 1757346730,
+                                        },
+                                        {
+                                            "content": "I don't have access to external tools or the internet. However, I can assist you with a wide range of topics by providing information, answering questions, and offering suggestions based on the knowledge I've been trained on. If there's anything specific you need help with, feel free to ask!",
+                                            "from_history": False,
+                                            "stop_after_tool_call": False,
+                                            "role": "assistant",
+                                            "metrics": {"input_tokens": 82, "output_tokens": 56, "total_tokens": 138},
+                                            "created_at": 1757346730,
+                                        },
+                                    ],
+                                    "tools": None,
+                                    "events": [
+                                        {
+                                            "created_at": 1757346730,
+                                            "event": "RunStarted",
+                                            "agent_id": "basic-agent",
+                                            "agent_name": "Basic Agent",
+                                            "run_id": "fcdf50f0-7c32-4593-b2ef-68a558774340",
+                                            "session_id": "80056af0-c7a5-4d69-b6a2-c3eba9f040e0",
+                                            "model": "gpt-4o",
+                                            "model_provider": "OpenAI",
+                                        },
+                                        {
+                                            "created_at": 1757346733,
+                                            "event": "MemoryUpdateStarted",
+                                            "agent_id": "basic-agent",
+                                            "agent_name": "Basic Agent",
+                                            "run_id": "fcdf50f0-7c32-4593-b2ef-68a558774340",
+                                            "session_id": "80056af0-c7a5-4d69-b6a2-c3eba9f040e0",
+                                        },
+                                        {
+                                            "created_at": 1757346734,
+                                            "event": "MemoryUpdateCompleted",
+                                            "agent_id": "basic-agent",
+                                            "agent_name": "Basic Agent",
+                                            "run_id": "fcdf50f0-7c32-4593-b2ef-68a558774340",
+                                            "session_id": "80056af0-c7a5-4d69-b6a2-c3eba9f040e0",
+                                        },
+                                        {
+                                            "created_at": 1757346734,
+                                            "event": "RunCompleted",
+                                            "agent_id": "basic-agent",
+                                            "agent_name": "Basic Agent",
+                                            "run_id": "fcdf50f0-7c32-4593-b2ef-68a558774340",
+                                            "session_id": "80056af0-c7a5-4d69-b6a2-c3eba9f040e0",
+                                            "content": "I don't have access to external tools or the internet. However, I can assist you with a wide range of topics by providing information, answering questions, and offering suggestions based on the knowledge I've been trained on. If there's anything specific you need help with, feel free to ask!",
+                                            "content_type": "str",
+                                            "metrics": {
+                                                "input_tokens": 82,
+                                                "output_tokens": 56,
+                                                "total_tokens": 138,
+                                                "time_to_first_token": 0.047505500027909875,
+                                                "duration": 4.840060166025069,
+                                            },
+                                        },
+                                    ],
+                                    "created_at": "2025-09-08T15:52:10Z",
+                                },
+                            }
+                        }
+                    }
+                },
+            },
+            404: {"description": "Session not found or has no runs", "model": NotFoundResponse},
+            422: {"description": "Invalid session type", "model": ValidationErrorResponse},
+        },
     )
     async def get_session_runs(
-        session_id: str = Path(..., description="Session ID", alias="session_id"),
-        session_type: SessionType = Query(default=SessionType.AGENT, description="Session type filter", alias="type"),
-        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+        session_id: str = Path(description="Session ID to get runs from"),
+        session_type: SessionType = Query(
+            default=SessionType.AGENT, description="Session type (agent, team, or workflow)", alias="type"
+        ),
+        db_id: Optional[str] = Query(default=None, description="Database ID to query runs from"),
     ) -> Union[List[RunSchema], List[TeamRunSchema], List[WorkflowRunSchema]]:
         db = get_db(dbs, db_id)
         session = db.get_session(session_id=session_id, session_type=session_type, deserialize=False)
@@ -122,19 +373,51 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
         else:
             return [RunSchema.from_dict(run) for run in runs]
 
-    @router.delete("/sessions/{session_id}", status_code=204, operation_id="delete_session")
+    @router.delete(
+        "/sessions/{session_id}",
+        status_code=204,
+        operation_id="delete_session",
+        summary="Delete Session",
+        description=(
+            "Permanently delete a specific session and all its associated runs. "
+            "This action cannot be undone and will remove all conversation history."
+        ),
+        responses={
+            204: {},
+            500: {"description": "Failed to delete session", "model": InternalServerErrorResponse},
+        },
+    )
     async def delete_session(
-        session_id: str = Path(...),
-        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+        session_id: str = Path(description="Session ID to delete"),
+        db_id: Optional[str] = Query(default=None, description="Database ID to use for deletion"),
     ) -> None:
         db = get_db(dbs, db_id)
         db.delete_session(session_id=session_id)
 
-    @router.delete("/sessions", status_code=204, operation_id="delete_sessions")
+    @router.delete(
+        "/sessions",
+        status_code=204,
+        operation_id="delete_sessions",
+        summary="Delete Multiple Sessions",
+        description=(
+            "Delete multiple sessions by their IDs in a single operation. "
+            "This action cannot be undone and will permanently remove all specified sessions and their runs."
+        ),
+        responses={
+            204: {"description": "Sessions deleted successfully"},
+            400: {
+                "description": "Invalid request - session IDs and types length mismatch",
+                "model": BadRequestResponse,
+            },
+            500: {"description": "Failed to delete sessions", "model": InternalServerErrorResponse},
+        },
+    )
     async def delete_sessions(
         request: DeleteSessionRequest,
-        session_type: SessionType = Query(default=SessionType.AGENT, description="Session type filter", alias="type"),
-        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+        session_type: SessionType = Query(
+            default=SessionType.AGENT, description="Default session type filter", alias="type"
+        ),
+        db_id: Optional[str] = Query(default=None, description="Database ID to use for deletion"),
     ) -> None:
         if len(request.session_ids) != len(request.session_types):
             raise HTTPException(status_code=400, detail="Session IDs and session types must have the same length")
@@ -145,13 +428,98 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
     @router.post(
         "/sessions/{session_id}/rename",
         response_model=Union[AgentSessionDetailSchema, TeamSessionDetailSchema, WorkflowSessionDetailSchema],
+        status_code=200,
         operation_id="rename_session",
+        summary="Rename Session",
+        description=(
+            "Update the name of an existing session. Useful for organizing and categorizing "
+            "sessions with meaningful names for better identification and management."
+        ),
+        responses={
+            200: {
+                "description": "Session renamed successfully",
+                "content": {
+                    "application/json": {
+                        "examples": {
+                            "agent_session_example": {
+                                "summary": "Example agent session response",
+                                "value": {
+                                    "user_id": "123",
+                                    "agent_session_id": "6f6cfbfd-9643-479a-ae47-b8f32eb4d710",
+                                    "session_id": "6f6cfbfd-9643-479a-ae47-b8f32eb4d710",
+                                    "session_name": "What tools do you have?",
+                                    "session_summary": {
+                                        "summary": "The user and assistant engaged in a conversation about the tools the agent has available.",
+                                        "updated_at": "2025-09-05T18:02:12.269392",
+                                    },
+                                    "session_state": {},
+                                    "agent_id": "basic-agent",
+                                    "total_tokens": 160,
+                                    "agent_data": {
+                                        "name": "Basic Agent",
+                                        "agent_id": "basic-agent",
+                                        "model": {"provider": "OpenAI", "name": "OpenAIChat", "id": "gpt-4o"},
+                                    },
+                                    "metrics": {
+                                        "input_tokens": 134,
+                                        "output_tokens": 26,
+                                        "total_tokens": 160,
+                                        "audio_input_tokens": 0,
+                                        "audio_output_tokens": 0,
+                                        "audio_total_tokens": 0,
+                                        "cache_read_tokens": 0,
+                                        "cache_write_tokens": 0,
+                                        "reasoning_tokens": 0,
+                                        "timer": None,
+                                        "time_to_first_token": None,
+                                        "duration": None,
+                                        "provider_metrics": None,
+                                        "additional_metrics": None,
+                                    },
+                                    "chat_history": [
+                                        {
+                                            "content": "<additional_information>\n- Use markdown to format your answers.\n- The current time is 2025-09-05 18:02:09.171627.\n</additional_information>\n\nYou have access to memories from previous interactions with the user that you can use:\n\n<memories_from_previous_interactions>\n- User really likes Digimon and Japan.\n- User really likes Japan.\n- User likes coffee.\n</memories_from_previous_interactions>\n\nNote: this information is from previous interactions and may be updated in this conversation. You should always prefer information from this conversation over the past memories.",
+                                            "from_history": False,
+                                            "stop_after_tool_call": False,
+                                            "role": "system",
+                                            "created_at": 1757088129,
+                                        },
+                                        {
+                                            "content": "What tools do you have?",
+                                            "from_history": False,
+                                            "stop_after_tool_call": False,
+                                            "role": "user",
+                                            "created_at": 1757088129,
+                                        },
+                                        {
+                                            "content": "I don't have access to external tools or the internet. However, I can assist you with a wide range of topics by providing information, answering questions, and offering suggestions based on the knowledge I've been trained on. If there's anything specific you need help with, feel free to ask!",
+                                            "from_history": False,
+                                            "stop_after_tool_call": False,
+                                            "role": "assistant",
+                                            "metrics": {"input_tokens": 134, "output_tokens": 26, "total_tokens": 160},
+                                            "created_at": 1757088129,
+                                        },
+                                    ],
+                                    "created_at": "2025-09-05T16:02:09Z",
+                                    "updated_at": "2025-09-05T16:02:09Z",
+                                },
+                            }
+                        }
+                    }
+                },
+            },
+            400: {"description": "Invalid session name", "model": BadRequestResponse},
+            404: {"description": "Session not found", "model": NotFoundResponse},
+            422: {"description": "Invalid session type or validation error", "model": ValidationErrorResponse},
+        },
     )
     async def rename_session(
-        session_id: str = Path(...),
-        session_type: SessionType = Query(default=SessionType.AGENT, description="Session type filter", alias="type"),
-        session_name: str = Body(embed=True),
-        db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+        session_id: str = Path(description="Session ID to rename"),
+        session_type: SessionType = Query(
+            default=SessionType.AGENT, description="Session type (agent, team, or workflow)", alias="type"
+        ),
+        session_name: str = Body(embed=True, description="New name for the session"),
+        db_id: Optional[str] = Query(default=None, description="Database ID to use for rename operation"),
     ) -> Union[AgentSessionDetailSchema, TeamSessionDetailSchema, WorkflowSessionDetailSchema]:
         db = get_db(dbs, db_id)
         session = db.rename_session(session_id=session_id, session_type=session_type, session_name=session_name)

agno/os/schema.py

@@ -23,6 +23,61 @@ from agno.team.team import Team
 from agno.workflow.workflow import Workflow
 
 
+class BadRequestResponse(BaseModel):
+    detail: str
+    error_code: Optional[str] = None
+
+    class Config:
+        json_schema_extra = {"example": {"detail": "Bad request", "error_code": "BAD_REQUEST"}}
+
+
+class NotFoundResponse(BaseModel):
+    detail: str
+    error_code: Optional[str] = None
+
+    class Config:
+        json_schema_extra = {"example": {"detail": "Not found", "error_code": "NOT_FOUND"}}
+
+
+class UnauthorizedResponse(BaseModel):
+    detail: str
+    error_code: Optional[str] = None
+
+    class Config:
+        json_schema_extra = {"example": {"detail": "Unauthorized access", "error_code": "UNAUTHORIZED"}}
+
+
+class UnauthenticatedResponse(BaseModel):
+    detail: str
+    error_code: Optional[str] = None
+
+    class Config:
+        json_schema_extra = {"example": {"detail": "Unauthenticated access", "error_code": "UNAUTHENTICATED"}}
+
+
+class ValidationErrorResponse(BaseModel):
+    detail: str
+    error_code: Optional[str] = None
+
+    class Config:
+        json_schema_extra = {"example": {"detail": "Validation error", "error_code": "VALIDATION_ERROR"}}
+
+
+class InternalServerErrorResponse(BaseModel):
+    detail: str
+    error_code: Optional[str] = None
+
+    class Config:
+        json_schema_extra = {"example": {"detail": "Internal server error", "error_code": "INTERNAL_SERVER_ERROR"}}
+
+
+class HealthResponse(BaseModel):
+    status: str
+
+    class Config:
+        json_schema_extra = {"example": {"status": "ok"}}
+
+
 class InterfaceResponse(BaseModel):
     type: str
     version: str
@@ -342,7 +397,6 @@ class TeamResponse(BaseModel):
     name: Optional[str] = None
     db_id: Optional[str] = None
     description: Optional[str] = None
-    mode: Optional[str] = None
     model: Optional[ModelResponse] = None
     tools: Optional[Dict[str, Any]] = None
     sessions: Optional[Dict[str, Any]] = None
@@ -541,7 +595,6 @@ class TeamResponse(BaseModel):
         return TeamResponse(
             id=team.id,
             name=team.name,
-            mode=team.mode,
             db_id=team.db.id if team.db else None,
             model=ModelResponse(**_team_model_data) if _team_model_data else None,
             tools=filter_meaningful_config(tools_info, {}),

agno/run/agent.py

@@ -43,6 +43,8 @@ class RunEvent(str, Enum):
     output_model_response_started = "OutputModelResponseStarted"
     output_model_response_completed = "OutputModelResponseCompleted"
 
+    custom_event = "CustomEvent"
+
 
 @dataclass
 class BaseAgentRunEvent(BaseRunOutputEvent):
@@ -226,6 +228,11 @@ class OutputModelResponseCompletedEvent(BaseAgentRunEvent):
     event: str = RunEvent.output_model_response_completed.value
 
 
+@dataclass
+class CustomEvent(BaseAgentRunEvent):
+    event: str = RunEvent.custom_event.value
+
+
 RunOutputEvent = Union[
     RunStartedEvent,
     RunContentEvent,
@@ -246,6 +253,7 @@ RunOutputEvent = Union[
     ParserModelResponseCompletedEvent,
     OutputModelResponseStartedEvent,
     OutputModelResponseCompletedEvent,
+    CustomEvent,
 ]
 
 
@@ -270,6 +278,7 @@ RUN_EVENT_TYPE_REGISTRY = {
     RunEvent.parser_model_response_completed.value: ParserModelResponseCompletedEvent,
     RunEvent.output_model_response_started.value: OutputModelResponseStartedEvent,
     RunEvent.output_model_response_completed.value: OutputModelResponseCompletedEvent,
+    RunEvent.custom_event.value: CustomEvent,
 }