agno 2.3.16__py3-none-any.whl → 2.3.17__py3-none-any.whl

agno/os/routers/teams/router.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, AsyncGenerator, List, Optional
+from typing import TYPE_CHECKING, Any, AsyncGenerator, List, Optional, Union
 from uuid import uuid4
 
 from fastapi import (
@@ -16,7 +16,7 @@ from fastapi.responses import JSONResponse, StreamingResponse
 from agno.exceptions import InputCheckError, OutputCheckError
 from agno.media import Audio, Image, Video
 from agno.media import File as FileMedia
-from agno.os.auth import get_authentication_dependency, require_resource_access
+from agno.os.auth import get_auth_token_from_request, get_authentication_dependency, require_resource_access
 from agno.os.routers.teams.schema import TeamResponse
 from agno.os.schema import (
     BadRequestResponse,
@@ -36,6 +36,7 @@ from agno.os.utils import (
     process_video,
 )
 from agno.run.team import RunErrorEvent as TeamRunErrorEvent
+from agno.team.remote import RemoteTeam
 from agno.team.team import Team
 from agno.utils.log import log_warning, logger
 
@@ -44,7 +45,7 @@ if TYPE_CHECKING:
 
 
 async def team_response_streamer(
-    team: Team,
+    team: Union[Team, RemoteTeam],
     message: str,
     session_id: Optional[str] = None,
     user_id: Optional[str] = None,
@@ -53,6 +54,7 @@ async def team_response_streamer(
     videos: Optional[List[Video]] = None,
     files: Optional[List[FileMedia]] = None,
     background_tasks: Optional[BackgroundTasks] = None,
+    auth_token: Optional[str] = None,
     **kwargs: Any,
 ) -> AsyncGenerator:
     """Run the given team asynchronously and yield its response"""
@@ -61,6 +63,15 @@ async def team_response_streamer(
         if background_tasks is not None:
             kwargs["background_tasks"] = background_tasks
 
+        if "stream_events" in kwargs:
+            stream_events = kwargs.pop("stream_events")
+        else:
+            stream_events = True
+
+        # Pass auth_token for remote teams
+        if auth_token and isinstance(team, RemoteTeam):
+            kwargs["auth_token"] = auth_token
+
         run_response = team.arun(
             input=message,
             session_id=session_id,
@@ -70,7 +81,7 @@ async def team_response_streamer(
             videos=videos,
             files=files,
             stream=True,
-            stream_events=True,
+            stream_events=stream_events,
             **kwargs,
         )
         async for run_response_chunk in run_response:
@@ -157,25 +168,25 @@ def get_team_router(
     ):
         kwargs = await get_request_kwargs(request, create_team_run)
 
-        if hasattr(request.state, "user_id"):
+        if hasattr(request.state, "user_id") and request.state.user_id is not None:
             if user_id:
                 log_warning("User ID parameter passed in both request state and kwargs, using request state")
             user_id = request.state.user_id
-        if hasattr(request.state, "session_id"):
+        if hasattr(request.state, "session_id") and request.state.session_id is not None:
             if session_id:
                 log_warning("Session ID parameter passed in both request state and kwargs, using request state")
             session_id = request.state.session_id
-        if hasattr(request.state, "session_state"):
+        if hasattr(request.state, "session_state") and request.state.session_state is not None:
             session_state = request.state.session_state
             if "session_state" in kwargs:
                 log_warning("Session state parameter passed in both request state and kwargs, using request state")
             kwargs["session_state"] = session_state
-        if hasattr(request.state, "dependencies"):
+        if hasattr(request.state, "dependencies") and request.state.dependencies is not None:
             dependencies = request.state.dependencies
             if "dependencies" in kwargs:
                 log_warning("Dependencies parameter passed in both request state and kwargs, using request state")
             kwargs["dependencies"] = dependencies
-        if hasattr(request.state, "metadata"):
+        if hasattr(request.state, "metadata") and request.state.metadata is not None:
             metadata = request.state.metadata
             if "metadata" in kwargs:
                 log_warning("Metadata parameter passed in both request state and kwargs, using request state")
@@ -246,6 +257,9 @@ def get_team_router(
                 else:
                     raise HTTPException(status_code=400, detail="Unsupported file type")
 
+        # Extract auth token for remote teams
+        auth_token = get_auth_token_from_request(request)
+
         if stream:
             return StreamingResponse(
                 team_response_streamer(
@@ -258,11 +272,16 @@ def get_team_router(
                     videos=base64_videos if base64_videos else None,
                     files=document_files if document_files else None,
                     background_tasks=background_tasks,
+                    auth_token=auth_token,
                     **kwargs,
                 ),
                 media_type="text/event-stream",
             )
         else:
+            # Pass auth_token for remote teams
+            if auth_token and isinstance(team, RemoteTeam):
+                kwargs["auth_token"] = auth_token
+
             try:
                 run_response = await team.arun(
                     input=message,
@@ -306,8 +325,9 @@ def get_team_router(
         if team is None:
             raise HTTPException(status_code=404, detail="Team not found")
 
-        if not team.cancel_run(run_id=run_id):
-            raise HTTPException(status_code=500, detail="Failed to cancel run")
+        cancelled = team.cancel_run(run_id=run_id)
+        if not cancelled:
+            raise HTTPException(status_code=500, detail="Failed to cancel run - run not found or already completed")
 
         return JSONResponse(content={}, status_code=200)
 
@@ -412,8 +432,11 @@ def get_team_router(
 
         teams = []
         for team in accessible_teams:
-            team_response = await TeamResponse.from_team(team=team)
-            teams.append(team_response)
+            if isinstance(team, RemoteTeam):
+                teams.append(await team.get_team_config())
+            else:
+                team_response = await TeamResponse.from_team(team=team)
+                teams.append(team_response)
 
         return teams
 
@@ -507,6 +530,9 @@ def get_team_router(
         if team is None:
             raise HTTPException(status_code=404, detail="Team not found")
 
-        return await TeamResponse.from_team(team)
+        if isinstance(team, RemoteTeam):
+            return await team.get_team_config()
+        else:
+            return await TeamResponse.from_team(team=team)
 
     return router

agno/os/routers/teams/schema.py

@@ -8,7 +8,6 @@ from agno.os.routers.agents.schema import AgentResponse
 from agno.os.schema import ModelResponse
 from agno.os.utils import (
     format_team_tools,
-    get_team_input_schema_dict,
 )
 from agno.run import RunContext
 from agno.run.team import TeamRunOutput
@@ -22,6 +21,7 @@ class TeamResponse(BaseModel):
     name: Optional[str] = None
     db_id: Optional[str] = None
     description: Optional[str] = None
+    role: Optional[str] = None
     model: Optional[ModelResponse] = None
     tools: Optional[Dict[str, Any]] = None
     sessions: Optional[Dict[str, Any]] = None
@@ -85,7 +85,6 @@ class TeamResponse(BaseModel):
             "use_json_mode": False,
             # Streaming defaults
             "stream_events": False,
-            "stream_intermediate_steps": False,
             "stream_member_events": False,
         }
 
@@ -103,6 +102,13 @@ class TeamResponse(BaseModel):
         team_tools = _tools
         formatted_tools = format_team_tools(team_tools) if team_tools else None
 
+        input_schema_dict = None
+        if team.input_schema is not None:
+            try:
+                input_schema_dict = team.input_schema.model_json_schema()
+            except Exception:
+                pass
+
         model_name = team.model.name or team.model.__class__.__name__ if team.model else None
         model_provider = team.model.provider or team.model.__class__.__name__ if team.model else ""
         model_id = team.model.id if team.model else None
@@ -132,6 +138,7 @@ class TeamResponse(BaseModel):
         }
 
         knowledge_info = {
+            "db_id": team.knowledge.contents_db.id if team.knowledge and team.knowledge.contents_db else None,
             "knowledge_table": knowledge_table,
             "enable_agentic_knowledge_filters": team.enable_agentic_knowledge_filters,
             "knowledge_filters": team.knowledge_filters,
@@ -227,7 +234,6 @@ class TeamResponse(BaseModel):
         streaming_info = {
             "stream": team.stream,
             "stream_events": team.stream_events,
-            "stream_intermediate_steps": team.stream_intermediate_steps,
             "stream_member_events": team.stream_member_events,
         }
 
@@ -253,6 +259,8 @@ class TeamResponse(BaseModel):
             id=team.id,
             name=team.name,
             db_id=team.db.id if team.db else None,
+            description=team.description,
+            role=team.role,
             model=ModelResponse(**_team_model_data) if _team_model_data else None,
             tools=filter_meaningful_config(tools_info, {}),
             sessions=filter_meaningful_config(sessions_info, team_defaults),
@@ -266,5 +274,5 @@ class TeamResponse(BaseModel):
             streaming=filter_meaningful_config(streaming_info, team_defaults),
             members=members if members else None,
             metadata=team.metadata,
-            input_schema=get_team_input_schema_dict(team),
+            input_schema=input_schema_dict,
         )

agno/os/routers/traces/traces.py

@@ -1,11 +1,11 @@
 import logging
 from typing import Optional, Union
 
-from fastapi import Depends, HTTPException, Query
+from fastapi import Depends, HTTPException, Query, Request
 from fastapi.routing import APIRouter
 
 from agno.db.base import AsyncBaseDb, BaseDb
-from agno.os.auth import get_authentication_dependency
+from agno.os.auth import get_auth_token_from_request, get_authentication_dependency
 from agno.os.routers.traces.schemas import (
     TraceDetail,
     TraceNode,
@@ -23,13 +23,14 @@ from agno.os.schema import (
 )
 from agno.os.settings import AgnoAPISettings
 from agno.os.utils import get_db, parse_datetime_to_utc
+from agno.remote.base import RemoteDb
 from agno.utils.log import log_error
 
 logger = logging.getLogger(__name__)
 
 
 def get_traces_router(
-    dbs: dict[str, list[Union[BaseDb, AsyncBaseDb]]], settings: AgnoAPISettings = AgnoAPISettings(), **kwargs
+    dbs: dict[str, list[Union[BaseDb, AsyncBaseDb, RemoteDb]]], settings: AgnoAPISettings = AgnoAPISettings(), **kwargs
 ) -> APIRouter:
     """Create traces router with comprehensive OpenAPI documentation for trace endpoints."""
     router = APIRouter(
@@ -46,7 +47,7 @@ def get_traces_router(
     return attach_routes(router=router, dbs=dbs)
 
 
-def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBaseDb]]]) -> APIRouter:
+def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBaseDb, RemoteDb]]]) -> APIRouter:
     @router.get(
         "/traces",
         response_model=PaginatedResponse[TraceSummary],
@@ -109,6 +110,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
         },
     )
     async def get_traces(
+        request: Request,
         run_id: Optional[str] = Query(default=None, description="Filter by run ID"),
         session_id: Optional[str] = Query(default=None, description="Filter by session ID"),
         user_id: Optional[str] = Query(default=None, description="Filter by user ID"),
@@ -134,6 +136,25 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
         # Get database using db_id or default to first available
         db = await get_db(dbs, db_id)
 
+        if isinstance(db, RemoteDb):
+            auth_token = get_auth_token_from_request(request)
+            headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else None
+            return await db.get_traces(
+                run_id=run_id,
+                session_id=session_id,
+                user_id=user_id,
+                agent_id=agent_id,
+                team_id=team_id,
+                workflow_id=workflow_id,
+                status=status,
+                start_time=start_time,
+                end_time=end_time,
+                limit=limit,
+                page=page,
+                db_id=db_id,
+                headers=headers,
+            )
+
         try:
             start_time_ms = time_module.time() * 1000
 
@@ -303,6 +324,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
         },
     )
     async def get_trace(
+        request: Request,
         trace_id: str,
         span_id: Optional[str] = Query(default=None, description="Optional: Span ID to retrieve specific span"),
         run_id: Optional[str] = Query(default=None, description="Optional: Run ID to retrieve trace for"),
@@ -312,6 +334,17 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
         # Get database using db_id or default to first available
         db = await get_db(dbs, db_id)
 
+        if isinstance(db, RemoteDb):
+            auth_token = get_auth_token_from_request(request)
+            headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else None
+            return await db.get_trace(
+                trace_id=trace_id,
+                span_id=span_id,
+                run_id=run_id,
+                db_id=db_id,
+                headers=headers,
+            )
+
         try:
             # If span_id is provided, return just that span
             if span_id:
@@ -408,6 +441,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
         },
     )
     async def get_trace_stats(
+        request: Request,
         user_id: Optional[str] = Query(default=None, description="Filter by user ID"),
         agent_id: Optional[str] = Query(default=None, description="Filter by agent ID"),
         team_id: Optional[str] = Query(default=None, description="Filter by team ID"),
@@ -430,6 +464,22 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
         # Get database using db_id or default to first available
         db = await get_db(dbs, db_id)
 
+        if isinstance(db, RemoteDb):
+            auth_token = get_auth_token_from_request(request)
+            headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else None
+            return await db.get_trace_session_stats(
+                user_id=user_id,
+                agent_id=agent_id,
+                team_id=team_id,
+                workflow_id=workflow_id,
+                start_time=start_time,
+                end_time=end_time,
+                limit=limit,
+                page=page,
+                db_id=db_id,
+                headers=headers,
+            )
+
         try:
             start_time_ms = time_module.time() * 1000