agno 2.1.1__py3-none-any.whl → 2.1.3__py3-none-any.whl

agno/os/app.py

@@ -64,11 +64,34 @@ async def mcp_lifespan(_, mcp_tools):
         await tool.close()
 
 
+def _combine_app_lifespans(lifespans: list) -> Any:
+    """Combine multiple FastAPI app lifespan context managers into one."""
+    if len(lifespans) == 1:
+        return lifespans[0]
+
+    from contextlib import asynccontextmanager
+
+    @asynccontextmanager
+    async def combined_lifespan(app):
+        async def _run_nested(index: int):
+            if index >= len(lifespans):
+                yield
+                return
+
+            async with lifespans[index](app):
+                async for _ in _run_nested(index + 1):
+                    yield
+
+        async for _ in _run_nested(0):
+            yield
+
+    return combined_lifespan
+
+
 class AgentOS:
     def __init__(
         self,
         id: Optional[str] = None,
-        os_id: Optional[str] = None,  # Deprecated
         name: Optional[str] = None,
         description: Optional[str] = None,
         version: Optional[str] = None,
@@ -76,16 +99,18 @@ class AgentOS:
         teams: Optional[List[Team]] = None,
         workflows: Optional[List[Workflow]] = None,
         interfaces: Optional[List[BaseInterface]] = None,
+        a2a_interface: bool = False,
         config: Optional[Union[str, AgentOSConfig]] = None,
         settings: Optional[AgnoAPISettings] = None,
         lifespan: Optional[Any] = None,
-        enable_mcp: bool = False,  # Deprecated
         enable_mcp_server: bool = False,
-        fastapi_app: Optional[FastAPI] = None,  # Deprecated
         base_app: Optional[FastAPI] = None,
-        replace_routes: Optional[bool] = None,  # Deprecated
         on_route_conflict: Literal["preserve_agentos", "preserve_base_app", "error"] = "preserve_agentos",
         telemetry: bool = True,
+        os_id: Optional[str] = None,  # Deprecated
+        enable_mcp: bool = False,  # Deprecated
+        fastapi_app: Optional[FastAPI] = None,  # Deprecated
+        replace_routes: Optional[bool] = None,  # Deprecated
     ):
         """Initialize AgentOS.
 
@@ -98,6 +123,7 @@ class AgentOS:
             teams: List of teams to include in the OS
             workflows: List of workflows to include in the OS
             interfaces: List of interfaces to include in the OS
+            a2a_interface: Whether to expose the OS agents and teams in an A2A server
             config: Configuration file path or AgentOSConfig instance
             settings: API settings for the OS
             lifespan: Optional lifespan context manager for the FastAPI app
@@ -105,6 +131,7 @@ class AgentOS:
             base_app: Optional base FastAPI app to use for the AgentOS. All routes and middleware will be added to this app.
             on_route_conflict: What to do when a route conflict is detected in case a custom base_app is provided.
             telemetry: Whether to enable telemetry
+
         """
         if not agents and not workflows and not teams:
             raise ValueError("Either agents, teams or workflows must be provided.")
@@ -115,6 +142,7 @@ class AgentOS:
         self.workflows: Optional[List[Workflow]] = workflows
         self.teams: Optional[List[Team]] = teams
         self.interfaces = interfaces or []
+        self.a2a_interface = a2a_interface
 
         self.settings: AgnoAPISettings = settings or AgnoAPISettings()
 
@@ -216,7 +244,7 @@ class AgentOS:
                         async with mcp_tools_lifespan(app):  # type: ignore
                             yield
 
-                app_lifespan = combined_lifespan  # type: ignore
+                app_lifespan = combined_lifespan
             else:
                 app_lifespan = mcp_tools_lifespan
 
@@ -233,6 +261,32 @@ class AgentOS:
     def get_app(self) -> FastAPI:
         if self.base_app:
             fastapi_app = self.base_app
+
+            # Initialize MCP server if enabled
+            if self.enable_mcp_server:
+                from agno.os.mcp import get_mcp_server
+
+                self._mcp_app = get_mcp_server(self)
+
+            # Collect all lifespans that need to be combined
+            lifespans = []
+
+            if fastapi_app.router.lifespan_context:
+                lifespans.append(fastapi_app.router.lifespan_context)
+
+            if self.mcp_tools:
+                lifespans.append(partial(mcp_lifespan, mcp_tools=self.mcp_tools))
+
+            if self.enable_mcp_server and self._mcp_app:
+                lifespans.append(self._mcp_app.lifespan)
+
+            if self.lifespan:
+                lifespans.append(self.lifespan)
+
+            # Combine lifespans and set them in the app
+            if lifespans:
+                fastapi_app.router.lifespan_context = _combine_app_lifespans(lifespans)
+
         else:
             if self.enable_mcp_server:
                 from contextlib import asynccontextmanager
@@ -251,7 +305,7 @@ class AgentOS:
                             async with self._mcp_app.lifespan(app):  # type: ignore
                                 yield
 
-                    final_lifespan = combined_lifespan  # type: ignore
+                    final_lifespan = combined_lifespan
 
                 fastapi_app = self._make_app(lifespan=final_lifespan)
             else:
@@ -263,10 +317,21 @@ class AgentOS:
         self._add_router(fastapi_app, get_health_router())
         self._add_router(fastapi_app, get_home_router(self))
 
+        has_a2a_interface = False
         for interface in self.interfaces:
+            if not has_a2a_interface and interface.__class__.__name__ == "A2A":
+                has_a2a_interface = True
             interface_router = interface.get_router()
             self._add_router(fastapi_app, interface_router)
 
+        # Add A2A interface if requested and not provided in self.interfaces
+        if self.a2a_interface and not has_a2a_interface:
+            from agno.os.interfaces.a2a import A2A
+
+            a2a_interface = A2A(agents=self.agents, teams=self.teams, workflows=self.workflows)
+            self.interfaces.append(a2a_interface)
+            self._add_router(fastapi_app, a2a_interface.get_router())
+
         self._auto_discover_databases()
         self._auto_discover_knowledge_instances()
 
@@ -400,18 +465,12 @@ class AgentOS:
                 self._register_db_with_validation(dbs, agent.db)
             if agent.knowledge and agent.knowledge.contents_db:
                 self._register_db_with_validation(knowledge_dbs, agent.knowledge.contents_db)
-                # Also add to general dbs if it's used for both purposes
-                if agent.knowledge.contents_db.id not in dbs:
-                    self._register_db_with_validation(dbs, agent.knowledge.contents_db)
 
         for team in self.teams or []:
             if team.db:
                 self._register_db_with_validation(dbs, team.db)
             if team.knowledge and team.knowledge.contents_db:
                 self._register_db_with_validation(knowledge_dbs, team.knowledge.contents_db)
-                # Also add to general dbs if it's used for both purposes
-                if team.knowledge.contents_db.id not in dbs:
-                    self._register_db_with_validation(dbs, team.knowledge.contents_db)
 
         for workflow in self.workflows or []:
             if workflow.db:
@@ -488,7 +547,6 @@ class AgentOS:
         if session_config.dbs is None:
             session_config.dbs = []
 
-        multiple_dbs: bool = len(self.dbs.keys()) > 1
         dbs_with_specific_config = [db.db_id for db in session_config.dbs]
 
         for db_id in self.dbs.keys():
@@ -496,9 +554,7 @@ class AgentOS:
                 session_config.dbs.append(
                     DatabaseConfig(
                         db_id=db_id,
-                        domain_config=SessionDomainConfig(
-                            display_name="Sessions" if not multiple_dbs else "Sessions in database '" + db_id + "'"
-                        ),
+                        domain_config=SessionDomainConfig(display_name=db_id),
                     )
                 )
 
@@ -510,7 +566,6 @@ class AgentOS:
         if memory_config.dbs is None:
             memory_config.dbs = []
 
-        multiple_dbs: bool = len(self.dbs.keys()) > 1
         dbs_with_specific_config = [db.db_id for db in memory_config.dbs]
 
         for db_id in self.dbs.keys():
@@ -518,9 +573,7 @@ class AgentOS:
                 memory_config.dbs.append(
                     DatabaseConfig(
                         db_id=db_id,
-                        domain_config=MemoryDomainConfig(
-                            display_name="Memory" if not multiple_dbs else "Memory in database '" + db_id + "'"
-                        ),
+                        domain_config=MemoryDomainConfig(display_name=db_id),
                     )
                 )
 
@@ -532,7 +585,6 @@ class AgentOS:
         if knowledge_config.dbs is None:
             knowledge_config.dbs = []
 
-        multiple_knowledge_dbs: bool = len(self.knowledge_dbs.keys()) > 1
         dbs_with_specific_config = [db.db_id for db in knowledge_config.dbs]
 
         # Only add databases that are actually used for knowledge contents
@@ -541,9 +593,7 @@ class AgentOS:
                 knowledge_config.dbs.append(
                     DatabaseConfig(
                         db_id=db_id,
-                        domain_config=KnowledgeDomainConfig(
-                            display_name="Knowledge" if not multiple_knowledge_dbs else "Knowledge in database " + db_id
-                        ),
+                        domain_config=KnowledgeDomainConfig(display_name=db_id),
                     )
                 )
 
@@ -555,7 +605,6 @@ class AgentOS:
         if metrics_config.dbs is None:
             metrics_config.dbs = []
 
-        multiple_dbs: bool = len(self.dbs.keys()) > 1
         dbs_with_specific_config = [db.db_id for db in metrics_config.dbs]
 
         for db_id in self.dbs.keys():
@@ -563,9 +612,7 @@ class AgentOS:
                 metrics_config.dbs.append(
                     DatabaseConfig(
                         db_id=db_id,
-                        domain_config=MetricsDomainConfig(
-                            display_name="Metrics" if not multiple_dbs else "Metrics in database '" + db_id + "'"
-                        ),
+                        domain_config=MetricsDomainConfig(display_name=db_id),
                     )
                 )
 
@@ -577,7 +624,6 @@ class AgentOS:
         if evals_config.dbs is None:
             evals_config.dbs = []
 
-        multiple_dbs: bool = len(self.dbs.keys()) > 1
         dbs_with_specific_config = [db.db_id for db in evals_config.dbs]
 
         for db_id in self.dbs.keys():
@@ -585,9 +631,7 @@ class AgentOS:
                 evals_config.dbs.append(
                     DatabaseConfig(
                         db_id=db_id,
-                        domain_config=EvalsDomainConfig(
-                            display_name="Evals" if not multiple_dbs else "Evals in database '" + db_id + "'"
-                        ),
+                        domain_config=EvalsDomainConfig(display_name=db_id),
                     )
                 )
 

agno/os/interfaces/a2a/__init__.py

@@ -0,0 +1,3 @@
+from agno.os.interfaces.a2a.a2a import A2A
+
+__all__ = ["A2A"]

agno/os/interfaces/a2a/a2a.py

@@ -0,0 +1,42 @@
+"""Main class for the A2A app, used to expose an Agno Agent, Team, or Workflow in an A2A compatible format."""
+
+from typing import Optional
+
+from fastapi.routing import APIRouter
+from typing_extensions import List
+
+from agno.agent import Agent
+from agno.os.interfaces.a2a.router import attach_routes
+from agno.os.interfaces.base import BaseInterface
+from agno.team import Team
+from agno.workflow import Workflow
+
+
+class A2A(BaseInterface):
+    type = "a2a"
+
+    router: APIRouter
+
+    def __init__(
+        self,
+        agents: Optional[List[Agent]] = None,
+        teams: Optional[List[Team]] = None,
+        workflows: Optional[List[Workflow]] = None,
+        prefix: str = "/a2a",
+        tags: Optional[List[str]] = None,
+    ):
+        self.agents = agents
+        self.teams = teams
+        self.workflows = workflows
+        self.prefix = prefix
+        self.tags = tags or ["A2A"]
+
+        if not (self.agents or self.teams or self.workflows):
+            raise ValueError("Agents, Teams, or Workflows are required to setup the A2A interface.")
+
+    def get_router(self, **kwargs) -> APIRouter:
+        self.router = APIRouter(prefix=self.prefix, tags=self.tags)  # type: ignore
+
+        self.router = attach_routes(router=self.router, agents=self.agents, teams=self.teams, workflows=self.workflows)
+
+        return self.router

agno/os/interfaces/a2a/router.py

@@ -0,0 +1,252 @@
+"""Async router handling exposing an Agno Agent or Team in an A2A compatible format."""
+
+from typing import Optional, Union
+from uuid import uuid4
+
+from fastapi import HTTPException, Request
+from fastapi.responses import StreamingResponse
+from fastapi.routing import APIRouter
+from typing_extensions import List
+
+try:
+    from a2a.types import SendMessageSuccessResponse, Task, TaskState, TaskStatus
+except ImportError as e:
+    raise ImportError("`a2a` not installed. Please install it with `pip install -U a2a`") from e
+
+from agno.agent import Agent
+from agno.os.interfaces.a2a.utils import (
+    map_a2a_request_to_run_input,
+    map_run_output_to_a2a_task,
+    stream_a2a_response_with_error_handling,
+)
+from agno.os.router import _get_request_kwargs
+from agno.os.utils import get_agent_by_id, get_team_by_id, get_workflow_by_id
+from agno.team import Team
+from agno.workflow import Workflow
+
+
+def attach_routes(
+    router: APIRouter,
+    agents: Optional[List[Agent]] = None,
+    teams: Optional[List[Team]] = None,
+    workflows: Optional[List[Workflow]] = None,
+) -> APIRouter:
+    if agents is None and teams is None and workflows is None:
+        raise ValueError("Agents, Teams, or Workflows are required to setup the A2A interface.")
+
+    @router.post(
+        "/message/send",
+        tags=["A2A"],
+        operation_id="send_message",
+        summary="Send message to Agent, Team, or Workflow (A2A Protocol)",
+        description="Send a message to an Agno Agent, Team, or Workflow. "
+        "The Agent, Team or Workflow is identified via the 'agentId' field in params.message or X-Agent-ID header. "
+        "Optional: Pass user ID via X-User-ID header (recommended) or 'userId' in params.message.metadata.",
+        response_model_exclude_none=True,
+        responses={
+            200: {
+                "description": "Message sent successfully",
+                "content": {
+                    "application/json": {
+                        "example": {
+                            "jsonrpc": "2.0",
+                            "id": "request-123",
+                            "result": {
+                                "task": {
+                                    "id": "task-456",
+                                    "context_id": "context-789",
+                                    "status": "completed",
+                                    "history": [
+                                        {
+                                            "message_id": "msg-1",
+                                            "role": "agent",
+                                            "parts": [{"kind": "text", "text": "Response from agent"}],
+                                        }
+                                    ],
+                                }
+                            },
+                        }
+                    }
+                },
+            },
+            400: {"description": "Invalid request or unsupported method"},
+            404: {"description": "Agent, Team, or Workflow not found"},
+        },
+        response_model=SendMessageSuccessResponse,
+    )
+    async def a2a_send_message(request: Request):
+        request_body = await request.json()
+        kwargs = await _get_request_kwargs(request, a2a_send_message)
+
+        # 1. Get the Agent, Team, or Workflow to run
+        agent_id = request_body.get("params", {}).get("message", {}).get("agentId") or request.headers.get("X-Agent-ID")
+        if not agent_id:
+            raise HTTPException(
+                status_code=400,
+                detail="Entity ID required. Provide it via 'agentId' in params.message or 'X-Agent-ID' header.",
+            )
+        entity: Optional[Union[Agent, Team, Workflow]] = None
+        if agents:
+            entity = get_agent_by_id(agent_id, agents)
+        if not entity and teams:
+            entity = get_team_by_id(agent_id, teams)
+        if not entity and workflows:
+            entity = get_workflow_by_id(agent_id, workflows)
+        if entity is None:
+            raise HTTPException(status_code=404, detail=f"Agent, Team, or Workflow with ID '{agent_id}' not found")
+
+        # 2. Map the request to our run_input and run variables
+        run_input = await map_a2a_request_to_run_input(request_body, stream=False)
+        context_id = request_body.get("params", {}).get("message", {}).get("contextId")
+        user_id = request.headers.get("X-User-ID")
+        if not user_id:
+            user_id = request_body.get("params", {}).get("message", {}).get("metadata", {}).get("userId")
+
+        # 3. Run the agent, team, or workflow
+        try:
+            if isinstance(entity, Workflow):
+                response = await entity.arun(
+                    input=run_input.input_content,
+                    images=list(run_input.images) if run_input.images else None,
+                    videos=list(run_input.videos) if run_input.videos else None,
+                    audio=list(run_input.audios) if run_input.audios else None,
+                    files=list(run_input.files) if run_input.files else None,
+                    session_id=context_id,
+                    user_id=user_id,
+                    **kwargs,
+                )
+            else:
+                response = await entity.arun(
+                    input=run_input.input_content,
+                    images=run_input.images,
+                    videos=run_input.videos,
+                    audio=run_input.audios,
+                    files=run_input.files,
+                    session_id=context_id,
+                    user_id=user_id,
+                    **kwargs,
+                )
+
+            # 4. Send the response
+            a2a_task = map_run_output_to_a2a_task(response)
+            return SendMessageSuccessResponse(
+                id=request_body.get("id", "unknown"),
+                result=a2a_task,
+            )
+
+        # Handle all critical errors
+        except Exception as e:
+            from a2a.types import Message as A2AMessage
+            from a2a.types import Part, Role, TextPart
+
+            error_message = A2AMessage(
+                message_id=str(uuid4()),
+                role=Role.agent,
+                parts=[Part(root=TextPart(text=f"Error: {str(e)}"))],
+                context_id=context_id or str(uuid4()),
+            )
+            failed_task = Task(
+                id=str(uuid4()),
+                context_id=context_id or str(uuid4()),
+                status=TaskStatus(state=TaskState.failed),
+                history=[error_message],
+            )
+
+            return SendMessageSuccessResponse(
+                id=request_body.get("id", "unknown"),
+                result=failed_task,
+            )
+
+    @router.post(
+        "/message/stream",
+        tags=["A2A"],
+        operation_id="stream_message",
+        summary="Stream message to Agent, Team, or Workflow (A2A Protocol)",
+        description="Stream a message to an Agno Agent, Team, or Workflow."
+        "The Agent, Team or Workflow is identified via the 'agentId' field in params.message or X-Agent-ID header. "
+        "Optional: Pass user ID via X-User-ID header (recommended) or 'userId' in params.message.metadata. "
+        "Returns real-time updates as newline-delimited JSON (NDJSON).",
+        response_model_exclude_none=True,
+        responses={
+            200: {
+                "description": "Streaming response with task updates",
+                "content": {
+                    "application/x-ndjson": {
+                        "example": '{"jsonrpc":"2.0","id":"request-123","result":{"taskId":"task-456","status":"working"}}\n'
+                        '{"jsonrpc":"2.0","id":"request-123","result":{"messageId":"msg-1","role":"agent","parts":[{"kind":"text","text":"Response"}]}}\n'
+                    }
+                },
+            },
+            400: {"description": "Invalid request or unsupported method"},
+            404: {"description": "Agent, Team, or Workflow not found"},
+        },
+    )
+    async def a2a_stream_message(request: Request):
+        request_body = await request.json()
+        kwargs = await _get_request_kwargs(request, a2a_stream_message)
+
+        # 1. Get the Agent, Team, or Workflow to run
+        agent_id = request_body.get("params", {}).get("message", {}).get("agentId")
+        if not agent_id:
+            agent_id = request.headers.get("X-Agent-ID")
+        if not agent_id:
+            raise HTTPException(
+                status_code=400,
+                detail="Entity ID required. Provide 'agentId' in params.message or 'X-Agent-ID' header.",
+            )
+        entity: Optional[Union[Agent, Team, Workflow]] = None
+        if agents:
+            entity = get_agent_by_id(agent_id, agents)
+        if not entity and teams:
+            entity = get_team_by_id(agent_id, teams)
+        if not entity and workflows:
+            entity = get_workflow_by_id(agent_id, workflows)
+        if entity is None:
+            raise HTTPException(status_code=404, detail=f"Agent, Team, or Workflow with ID '{agent_id}' not found")
+
+        # 2. Map the request to our run_input and run variables
+        run_input = await map_a2a_request_to_run_input(request_body, stream=True)
+        context_id = request_body.get("params", {}).get("message", {}).get("contextId")
+        user_id = request.headers.get("X-User-ID")
+        if not user_id:
+            user_id = request_body.get("params", {}).get("message", {}).get("metadata", {}).get("userId")
+
+        # 3. Run the Agent, Team, or Workflow and stream the response
+        try:
+            if isinstance(entity, Workflow):
+                event_stream = entity.arun(
+                    input=run_input.input_content,
+                    images=list(run_input.images) if run_input.images else None,
+                    videos=list(run_input.videos) if run_input.videos else None,
+                    audio=list(run_input.audios) if run_input.audios else None,
+                    files=list(run_input.files) if run_input.files else None,
+                    session_id=context_id,
+                    user_id=user_id,
+                    stream=True,
+                    stream_intermediate_steps=True,
+                    **kwargs,
+                )
+            else:
+                event_stream = entity.arun(  # type: ignore[assignment]
+                    input=run_input.input_content,
+                    images=run_input.images,
+                    videos=run_input.videos,
+                    audio=run_input.audios,
+                    files=run_input.files,
+                    session_id=context_id,
+                    user_id=user_id,
+                    stream=True,
+                    stream_intermediate_steps=True,
+                    **kwargs,
+                )
+
+            # 4. Stream the response
+            return StreamingResponse(
+                stream_a2a_response_with_error_handling(event_stream=event_stream, request_id=request_body["id"]),  # type: ignore[arg-type]
+                media_type="application/x-ndjson",
+            )
+
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to start run: {str(e)}")
+
+    return router