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

agno/os/router.py

@@ -1,12 +1,17 @@
-from typing import TYPE_CHECKING, List, Union, cast
+import json
+from typing import TYPE_CHECKING, List, cast
 
 from fastapi import (
     APIRouter,
     Depends,
+    HTTPException,
+    WebSocket,
 )
 
-from agno.agent.agent import Agent
-from agno.os.auth import get_authentication_dependency
+from agno.exceptions import RemoteServerUnavailableError
+from agno.os.auth import get_authentication_dependency, validate_websocket_token
+from agno.os.managers import websocket_manager
+from agno.os.routers.workflows.router import handle_workflow_subscription, handle_workflow_via_websocket
 from agno.os.schema import (
     AgentSummaryResponse,
     BadRequestResponse,
@@ -21,7 +26,7 @@ from agno.os.schema import (
     WorkflowSummaryResponse,
 )
 from agno.os.settings import AgnoAPISettings
-from agno.team.team import Team
+from agno.utils.log import logger
 
 if TYPE_CHECKING:
     from agno.os.app import AgentOS
@@ -135,6 +140,27 @@ def get_base_router(
         },
     )
     async def config() -> ConfigResponse:
+        try:
+            agent_summaries = []
+            if os.agents:
+                for agent in os.agents:
+                    agent_summaries.append(AgentSummaryResponse.from_agent(agent))
+
+            team_summaries = []
+            if os.teams:
+                for team in os.teams:
+                    team_summaries.append(TeamSummaryResponse.from_team(team))
+
+            workflow_summaries = []
+            if os.workflows:
+                for workflow in os.workflows:
+                    workflow_summaries.append(WorkflowSummaryResponse.from_workflow(workflow))
+        except RemoteServerUnavailableError as e:
+            raise HTTPException(
+                status_code=502,
+                detail=f"Failed to fetch config from remote AgentOS: {e}",
+            )
+
         return ConfigResponse(
             os_id=os.id or "Unnamed OS",
             description=os.description,
@@ -146,10 +172,10 @@ def get_base_router(
             knowledge=os._get_knowledge_config(),
             evals=os._get_evals_config(),
             metrics=os._get_metrics_config(),
+            agents=agent_summaries,
+            teams=team_summaries,
+            workflows=workflow_summaries,
             traces=os._get_traces_config(),
-            agents=[AgentSummaryResponse.from_agent(agent) for agent in os.agents] if os.agents else [],
-            teams=[TeamSummaryResponse.from_team(team) for team in os.teams] if os.teams else [],
-            workflows=[WorkflowSummaryResponse.from_workflow(w) for w in os.workflows] if os.workflows else [],
             interfaces=[
                 InterfaceResponse(type=interface.type, version=interface.version, route=interface.prefix)
                 for interface in os.interfaces
@@ -183,20 +209,101 @@ def get_base_router(
     )
     async def get_models() -> List[Model]:
         """Return the list of all models used by agents and teams in the contextual OS"""
-        all_components: List[Union[Agent, Team]] = []
+        unique_models = {}
+
+        # Collect models from local agents
         if os.agents:
-            all_components.extend(os.agents)
-        if os.teams:
-            all_components.extend(os.teams)
+            for agent in os.agents:
+                model = cast(Model, agent.model)
+                if model and model.id is not None and model.provider is not None:
+                    key = (model.id, model.provider)
+                    if key not in unique_models:
+                        unique_models[key] = Model(id=model.id, provider=model.provider)
 
-        unique_models = {}
-        for item in all_components:
-            model = cast(Model, item.model)
-            if model.id is not None and model.provider is not None:
-                key = (model.id, model.provider)
-                if key not in unique_models:
-                    unique_models[key] = Model(id=model.id, provider=model.provider)
+        # Collect models from local teams
+        if os.teams:
+            for team in os.teams:
+                model = cast(Model, team.model)
+                if model and model.id is not None and model.provider is not None:
+                    key = (model.id, model.provider)
+                    if key not in unique_models:
+                        unique_models[key] = Model(id=model.id, provider=model.provider)
 
         return list(unique_models.values())
 
     return router
+
+
+def get_websocket_router(
+    os: "AgentOS",
+    settings: AgnoAPISettings = AgnoAPISettings(),
+) -> APIRouter:
+    """
+    Create WebSocket router without HTTP authentication dependencies.
+    WebSocket endpoints handle authentication internally via message-based auth.
+    """
+    ws_router = APIRouter()
+
+    @ws_router.websocket(
+        "/workflows/ws",
+        name="workflow_websocket",
+    )
+    async def workflow_websocket_endpoint(websocket: WebSocket):
+        """WebSocket endpoint for receiving real-time workflow events"""
+        requires_auth = bool(settings.os_security_key)
+        await websocket_manager.connect(websocket, requires_auth=requires_auth)
+
+        try:
+            while True:
+                data = await websocket.receive_text()
+                message = json.loads(data)
+                action = message.get("action")
+
+                # Handle authentication first
+                if action == "authenticate":
+                    token = message.get("token")
+                    if not token:
+                        await websocket.send_text(json.dumps({"event": "auth_error", "error": "Token is required"}))
+                        continue
+
+                    if validate_websocket_token(token, settings):
+                        await websocket_manager.authenticate_websocket(websocket)
+                    else:
+                        await websocket.send_text(json.dumps({"event": "auth_error", "error": "Invalid token"}))
+                        continue
+
+                # Check authentication for all other actions (only when required)
+                elif requires_auth and not websocket_manager.is_authenticated(websocket):
+                    await websocket.send_text(
+                        json.dumps(
+                            {
+                                "event": "auth_required",
+                                "error": "Authentication required. Send authenticate action with valid token.",
+                            }
+                        )
+                    )
+                    continue
+
+                # Handle authenticated actions
+                elif action == "ping":
+                    await websocket.send_text(json.dumps({"event": "pong"}))
+
+                elif action == "start-workflow":
+                    # Handle workflow execution directly via WebSocket
+                    await handle_workflow_via_websocket(websocket, message, os)
+
+                elif action == "reconnect":
+                    # Subscribe/reconnect to an existing workflow run
+                    await handle_workflow_subscription(websocket, message, os)
+
+                else:
+                    await websocket.send_text(json.dumps({"event": "error", "error": f"Unknown action: {action}"}))
+
+        except Exception as e:
+            if "1012" not in str(e) and "1001" not in str(e):
+                logger.error(f"WebSocket error: {e}")
+        finally:
+            # Clean up the websocket connection
+            await websocket_manager.disconnect_websocket(websocket)
+
+    return ws_router

agno/os/routers/agents/router.py

@@ -1,5 +1,5 @@
 import json
-from typing import TYPE_CHECKING, Any, AsyncGenerator, List, Optional, cast
+from typing import TYPE_CHECKING, Any, AsyncGenerator, List, Optional, Union, cast
 from uuid import uuid4
 
 from fastapi import (
@@ -15,10 +15,11 @@ from fastapi import (
 from fastapi.responses import JSONResponse, StreamingResponse
 
 from agno.agent.agent import Agent
+from agno.agent.remote import RemoteAgent
 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.agents.schema import AgentResponse
 from agno.os.schema import (
     BadRequestResponse,
@@ -45,7 +46,7 @@ if TYPE_CHECKING:
 
 
 async def agent_response_streamer(
-    agent: Agent,
+    agent: Union[Agent, RemoteAgent],
     message: str,
     session_id: Optional[str] = None,
     user_id: Optional[str] = None,
@@ -54,6 +55,7 @@ async def agent_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:
     try:
@@ -61,6 +63,15 @@ async def agent_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 agents
+        if auth_token and isinstance(agent, RemoteAgent):
+            kwargs["auth_token"] = auth_token
+
         run_response = agent.arun(
             input=message,
             session_id=session_id,
@@ -70,7 +81,7 @@ async def agent_response_streamer(
             videos=videos,
             files=files,
             stream=True,
-            stream_events=True,
+            stream_events=stream_events,
             **kwargs,
         )
         async for run_response_chunk in run_response:
@@ -94,14 +105,20 @@ async def agent_response_streamer(
 
 
 async def agent_continue_response_streamer(
-    agent: Agent,
-    run_id: Optional[str] = None,
-    updated_tools: Optional[List] = None,
+    agent: Union[Agent, RemoteAgent],
+    run_id: str,
+    updated_tools: List,
     session_id: Optional[str] = None,
     user_id: Optional[str] = None,
     background_tasks: Optional[BackgroundTasks] = None,
+    auth_token: Optional[str] = None,
 ) -> AsyncGenerator:
     try:
+        # Build kwargs for remote agent auth
+        extra_kwargs: dict = {}
+        if auth_token and isinstance(agent, RemoteAgent):
+            extra_kwargs["auth_token"] = auth_token
+
         continue_response = agent.acontinue_run(
             run_id=run_id,
             updated_tools=updated_tools,
@@ -110,6 +127,7 @@ async def agent_continue_response_streamer(
             stream=True,
             stream_events=True,
             background_tasks=background_tasks,
+            **extra_kwargs,
         )
         async for run_response_chunk in continue_response:
             yield format_sse_event(run_response_chunk)  # type: ignore
@@ -194,32 +212,32 @@ def get_agent_router(
         request: Request,
         background_tasks: BackgroundTasks,
         message: str = Form(...),
-        stream: bool = Form(False),
+        stream: bool = Form(True),
         session_id: Optional[str] = Form(None),
         user_id: Optional[str] = Form(None),
         files: Optional[List[UploadFile]] = File(None),
     ):
         kwargs = await get_request_kwargs(request, create_agent_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")
@@ -320,6 +338,9 @@ def get_agent_router(
                 else:
                     raise HTTPException(status_code=400, detail="Unsupported file type")
 
+        # Extract auth token for remote agents
+        auth_token = get_auth_token_from_request(request)
+
         if stream:
             return StreamingResponse(
                 agent_response_streamer(
@@ -332,11 +353,16 @@ def get_agent_router(
                     videos=base64_videos if base64_videos else None,
                     files=input_files if input_files else None,
                     background_tasks=background_tasks,
+                    auth_token=auth_token,
                     **kwargs,
                 ),
                 media_type="text/event-stream",
             )
         else:
+            # Pass auth_token for remote agents
+            if auth_token and isinstance(agent, RemoteAgent):
+                kwargs["auth_token"] = auth_token
+
             try:
                 run_response = cast(
                     RunOutput,
@@ -383,8 +409,9 @@ def get_agent_router(
         if agent is None:
             raise HTTPException(status_code=404, detail="Agent not found")
 
-        if not agent.cancel_run(run_id=run_id):
-            raise HTTPException(status_code=500, detail="Failed to cancel run")
+        cancelled = agent.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)
 
@@ -426,9 +453,9 @@ def get_agent_router(
         user_id: Optional[str] = Form(None),
         stream: bool = Form(True),
     ):
-        if hasattr(request.state, "user_id"):
+        if hasattr(request.state, "user_id") and request.state.user_id is not None:
             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:
             session_id = request.state.session_id
 
         # Parse the JSON string manually
@@ -447,7 +474,7 @@ def get_agent_router(
             )
 
         # Convert tools dict to ToolExecution objects if provided
-        updated_tools = None
+        updated_tools = []
         if tools_data:
             try:
                 from agno.models.response import ToolExecution
@@ -456,6 +483,9 @@ def get_agent_router(
             except Exception as e:
                 raise HTTPException(status_code=400, detail=f"Invalid structure or content for tools: {str(e)}")
 
+        # Extract auth token for remote agents
+        auth_token = get_auth_token_from_request(request)
+
         if stream:
             return StreamingResponse(
                 agent_continue_response_streamer(
@@ -465,20 +495,27 @@ def get_agent_router(
                     session_id=session_id,
                     user_id=user_id,
                     background_tasks=background_tasks,
+                    auth_token=auth_token,
                 ),
                 media_type="text/event-stream",
             )
         else:
+            # Build extra kwargs for remote agent auth
+            extra_kwargs: dict = {}
+            if auth_token and isinstance(agent, RemoteAgent):
+                extra_kwargs["auth_token"] = auth_token
+
             try:
                 run_response_obj = cast(
                     RunOutput,
-                    await agent.acontinue_run(
+                    await agent.acontinue_run(  # type: ignore
                         run_id=run_id,  # run_id from path
                         updated_tools=updated_tools,
                         session_id=session_id,
                         user_id=user_id,
                         stream=False,
                         background_tasks=background_tasks,
+                        **extra_kwargs,
                     ),
                 )
                 return run_response_obj.to_dict()
@@ -545,8 +582,11 @@ def get_agent_router(
 
         agents = []
         for agent in accessible_agents:
-            agent_response = await AgentResponse.from_agent(agent=agent)
-            agents.append(agent_response)
+            if isinstance(agent, RemoteAgent):
+                agents.append(await agent.get_agent_config())
+            else:
+                agent_response = await AgentResponse.from_agent(agent=agent)
+                agents.append(agent_response)
 
         return agents
 
@@ -594,6 +634,9 @@ def get_agent_router(
         if agent is None:
             raise HTTPException(status_code=404, detail="Agent not found")
 
-        return await AgentResponse.from_agent(agent)
+        if isinstance(agent, RemoteAgent):
+            return await agent.get_agent_config()
+        else:
+            return await AgentResponse.from_agent(agent=agent)
 
     return router

agno/os/routers/agents/schema.py

@@ -8,7 +8,6 @@ from agno.models.message import Message
 from agno.os.schema import ModelResponse
 from agno.os.utils import (
     format_tools,
-    get_agent_input_schema_dict,
 )
 from agno.run import RunContext
 from agno.run.agent import RunOutput
@@ -20,6 +19,8 @@ class AgentResponse(BaseModel):
     id: Optional[str] = None
     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
@@ -93,7 +94,6 @@ class AgentResponse(BaseModel):
             "use_json_mode": False,
             # Streaming defaults
             "stream_events": False,
-            "stream_intermediate_steps": False,
         }
 
         session_id = str(uuid4())
@@ -110,6 +110,16 @@ class AgentResponse(BaseModel):
         if additional_input and isinstance(additional_input[0], Message):
             additional_input = [message.to_dict() for message in additional_input]  # type: ignore
 
+        input_schema_dict = None
+        if agent.input_schema is not None:
+            if isinstance(agent.input_schema, dict):
+                input_schema_dict = agent.input_schema
+            else:
+                try:
+                    input_schema_dict = agent.input_schema.model_json_schema()
+                except Exception:
+                    pass
+
         # Build model only if it has at least one non-null field
         model_name = agent.model.name if (agent.model and agent.model.name) else None
         model_provider = agent.model.provider if (agent.model and agent.model.provider) else None
@@ -142,6 +152,7 @@ class AgentResponse(BaseModel):
         }
 
         knowledge_info = {
+            "db_id": agent.knowledge.contents_db.id if agent.knowledge and agent.knowledge.contents_db else None,
             "knowledge_table": knowledge_table,
             "enable_agentic_knowledge_filters": agent.enable_agentic_knowledge_filters,
             "knowledge_filters": agent.knowledge_filters,
@@ -250,13 +261,14 @@ class AgentResponse(BaseModel):
         streaming_info = {
             "stream": agent.stream,
             "stream_events": agent.stream_events,
-            "stream_intermediate_steps": agent.stream_intermediate_steps,
         }
 
         return AgentResponse(
             id=agent.id,
             name=agent.name,
             db_id=agent.db.id if agent.db else None,
+            description=agent.description,
+            role=agent.role,
             model=ModelResponse(**_agent_model_data) if _agent_model_data else None,
             tools=filter_meaningful_config(tools_info, {}),
             sessions=filter_meaningful_config(sessions_info, agent_defaults),
@@ -270,5 +282,5 @@ class AgentResponse(BaseModel):
             streaming=filter_meaningful_config(streaming_info, agent_defaults),
             introduction=agent.introduction,
             metadata=agent.metadata,
-            input_schema=get_agent_input_schema_dict(agent),
+            input_schema=input_schema_dict,
         )

agno/os/routers/database.py

@@ -22,6 +22,8 @@ from agno.os.settings import AgnoAPISettings
 from agno.os.utils import (
     get_db,
 )
+from agno.remote.base import RemoteDb
+from agno.utils.log import log_info
 
 if TYPE_CHECKING:
     from agno.os.app import AgentOS
@@ -45,6 +47,9 @@ def get_database_router(
 
     async def _migrate_single_db(db, target_version: Optional[str] = None) -> None:
         """Migrate a single database."""
+        if isinstance(db, RemoteDb):
+            log_info("Skipping logs for remote DB")
+
         if target_version:
             # Use the session table as proxy for the database schema version
             if isinstance(db, AsyncBaseDb):