agno 2.0.10__py3-none-any.whl → 2.1.0__py3-none-any.whl

agno/os/app.py

@@ -1,7 +1,7 @@
 from contextlib import asynccontextmanager
 from functools import partial
 from os import getenv
-from typing import Any, Dict, List, Optional, Set, Union
+from typing import Any, Dict, List, Literal, Optional, Union
 from uuid import uuid4
 
 from fastapi import APIRouter, FastAPI, HTTPException
@@ -12,6 +12,7 @@ from rich.panel import Panel
 from starlette.requests import Request
 
 from agno.agent.agent import Agent
+from agno.db.base import BaseDb
 from agno.os.config import (
     AgentOSConfig,
     DatabaseConfig,
@@ -36,7 +37,13 @@ from agno.os.routers.memory import get_memory_router
 from agno.os.routers.metrics import get_metrics_router
 from agno.os.routers.session import get_session_router
 from agno.os.settings import AgnoAPISettings
-from agno.os.utils import update_cors_middleware
+from agno.os.utils import (
+    collect_mcp_tools_from_team,
+    collect_mcp_tools_from_workflow,
+    find_conflicting_routes,
+    load_yaml_config,
+    update_cors_middleware,
+)
 from agno.team.team import Team
 from agno.utils.log import logger
 from agno.utils.string import generate_id, generate_id_from_name
@@ -44,7 +51,7 @@ from agno.workflow.workflow import Workflow
 
 
 @asynccontextmanager
-async def mcp_lifespan(app, mcp_tools):
+async def mcp_lifespan(_, mcp_tools):
     """Manage MCP connection lifecycle inside a FastAPI app"""
     # Startup logic: connect to all contextual MCP servers
     for tool in mcp_tools:
@@ -60,7 +67,8 @@ async def mcp_lifespan(app, mcp_tools):
 class AgentOS:
     def __init__(
         self,
-        os_id: Optional[str] = None,
+        id: Optional[str] = None,
+        os_id: Optional[str] = None,  # Deprecated
         name: Optional[str] = None,
         description: Optional[str] = None,
         version: Optional[str] = None,
@@ -70,16 +78,19 @@ class AgentOS:
         interfaces: Optional[List[BaseInterface]] = None,
         config: Optional[Union[str, AgentOSConfig]] = None,
         settings: Optional[AgnoAPISettings] = None,
-        fastapi_app: Optional[FastAPI] = None,
         lifespan: Optional[Any] = None,
-        enable_mcp: bool = False,
-        replace_routes: bool = True,
+        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,
     ):
         """Initialize AgentOS.
 
         Args:
-            os_id: Unique identifier for this AgentOS instance
+            id: Unique identifier for this AgentOS instance
             name: Name of the AgentOS instance
             description: Description of the AgentOS instance
             version: Version of the AgentOS instance
@@ -89,18 +100,16 @@ class AgentOS:
             interfaces: List of interfaces to include in the OS
             config: Configuration file path or AgentOSConfig instance
             settings: API settings for the OS
-            fastapi_app: Optional custom FastAPI app to use instead of creating a new one
             lifespan: Optional lifespan context manager for the FastAPI app
-            enable_mcp: Whether to enable MCP (Model Context Protocol)
-            replace_routes: If False and using a custom fastapi_app, skip AgentOS routes that
-                          conflict with existing routes, preferring the user's custom routes.
-                          If True (default), AgentOS routes will override conflicting custom routes.
+            enable_mcp_server: Whether to enable MCP (Model Context Protocol)
+            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.")
 
-        self.config = self._load_yaml_config(config) if isinstance(config, str) else config
+        self.config = load_yaml_config(config) if isinstance(config, str) else config
 
         self.agents: Optional[List[Agent]] = agents
         self.workflows: Optional[List[Workflow]] = workflows
@@ -110,27 +119,42 @@ class AgentOS:
         self.settings: AgnoAPISettings = settings or AgnoAPISettings()
 
         self._app_set = False
-        self.fastapi_app: Optional[FastAPI] = None
-        if fastapi_app:
-            self.fastapi_app = fastapi_app
+
+        if base_app:
+            self.base_app: Optional[FastAPI] = base_app
+            self._app_set = True
+            self.on_route_conflict = on_route_conflict
+        elif fastapi_app:
+            self.base_app = fastapi_app
             self._app_set = True
+            if replace_routes is not None:
+                self.on_route_conflict = "preserve_agentos" if replace_routes else "preserve_base_app"
+            else:
+                self.on_route_conflict = on_route_conflict
+        else:
+            self.base_app = None
+            self._app_set = False
+            self.on_route_conflict = on_route_conflict
 
         self.interfaces = interfaces or []
 
-        self.os_id = os_id
         self.name = name
+
+        self.id = id or os_id
+        if not self.id:
+            self.id = generate_id(self.name) if self.name else str(uuid4())
+
         self.version = version
         self.description = description
 
-        self.replace_routes = replace_routes
-
         self.telemetry = telemetry
 
-        self.enable_mcp = enable_mcp
+        self.enable_mcp_server = enable_mcp or enable_mcp_server
         self.lifespan = lifespan
 
         # List of all MCP tools used inside the AgentOS
-        self.mcp_tools = []
+        self.mcp_tools: List[Any] = []
+        self._mcp_app: Optional[Any] = None
 
         if self.agents:
             for agent in self.agents:
@@ -140,7 +164,8 @@ class AgentOS:
                         # Checking if the tool is a MCPTools or MultiMCPTools instance
                         type_name = type(tool).__name__
                         if type_name in ("MCPTools", "MultiMCPTools"):
-                            self.mcp_tools.append(tool)
+                            if tool not in self.mcp_tools:
+                                self.mcp_tools.append(tool)
 
                 agent.initialize_agent()
 
@@ -149,13 +174,8 @@ class AgentOS:
 
         if self.teams:
             for team in self.teams:
-                # Track all MCP tools to later handle their connection
-                if team.tools:
-                    for tool in team.tools:
-                        # Checking if the tool is a MCPTools or MultiMCPTools instance
-                        type_name = type(tool).__name__
-                        if type_name in ("MCPTools", "MultiMCPTools"):
-                            self.mcp_tools.append(tool)
+                # Track all MCP tools recursively
+                collect_mcp_tools_from_team(team, self.mcp_tools)
 
                 team.initialize_team()
 
@@ -171,17 +191,15 @@ class AgentOS:
 
         if self.workflows:
             for workflow in self.workflows:
-                # TODO: track MCP tools in workflow members
+                # Track MCP tools recursively in workflow members
+                collect_mcp_tools_from_workflow(workflow, self.mcp_tools)
                 if not workflow.id:
                     workflow.id = generate_id_from_name(workflow.name)
 
-        if not self.os_id:
-            self.os_id = generate_id(self.name) if self.name else str(uuid4())
-
         if self.telemetry:
             from agno.api.os import OSLaunch, log_os_telemetry
 
-            log_os_telemetry(launch=OSLaunch(os_id=self.os_id, data=self._get_telemetry_data()))
+            log_os_telemetry(launch=OSLaunch(os_id=self.id, data=self._get_telemetry_data()))
 
     def _make_app(self, lifespan: Optional[Any] = None) -> FastAPI:
         # Adjust the FastAPI app lifespan to handle MCP connections if relevant
@@ -213,39 +231,41 @@ class AgentOS:
         )
 
     def get_app(self) -> FastAPI:
-        if not self.fastapi_app:
-            if self.enable_mcp:
+        if self.base_app:
+            fastapi_app = self.base_app
+        else:
+            if self.enable_mcp_server:
                 from contextlib import asynccontextmanager
 
                 from agno.os.mcp import get_mcp_server
 
-                self.mcp_app = get_mcp_server(self)
+                self._mcp_app = get_mcp_server(self)
 
-                final_lifespan = self.mcp_app.lifespan
+                final_lifespan = self._mcp_app.lifespan  # type: ignore
                 if self.lifespan is not None:
                     # Combine both lifespans
                     @asynccontextmanager
                     async def combined_lifespan(app: FastAPI):
                         # Run both lifespans
                         async with self.lifespan(app):  # type: ignore
-                            async with self.mcp_app.lifespan(app):  # type: ignore
+                            async with self._mcp_app.lifespan(app):  # type: ignore
                                 yield
 
                     final_lifespan = combined_lifespan  # type: ignore
 
-                self.fastapi_app = self._make_app(lifespan=final_lifespan)
+                fastapi_app = self._make_app(lifespan=final_lifespan)
             else:
-                self.fastapi_app = self._make_app(lifespan=self.lifespan)
+                fastapi_app = self._make_app(lifespan=self.lifespan)
 
-        # Add routes with conflict detection
-        self._add_router(get_base_router(self, settings=self.settings))
-        self._add_router(get_websocket_router(self, settings=self.settings))
-        self._add_router(get_health_router())
-        self._add_router(get_home_router(self))
+        # Add routes
+        self._add_router(fastapi_app, get_base_router(self, settings=self.settings))
+        self._add_router(fastapi_app, get_websocket_router(self, settings=self.settings))
+        self._add_router(fastapi_app, get_health_router())
+        self._add_router(fastapi_app, get_home_router(self))
 
         for interface in self.interfaces:
             interface_router = interface.get_router()
-            self._add_router(interface_router)
+            self._add_router(fastapi_app, interface_router)
 
         self._auto_discover_databases()
         self._auto_discover_knowledge_instances()
@@ -259,17 +279,19 @@ class AgentOS:
         ]
 
         for router in routers:
-            self._add_router(router)
+            self._add_router(fastapi_app, router)
 
         # Mount MCP if needed
-        if self.enable_mcp and self.mcp_app:
-            self.fastapi_app.mount("/", self.mcp_app)
+        if self.enable_mcp_server and self._mcp_app:
+            fastapi_app.mount("/", self._mcp_app)
+        else:
+            # Add the home router
+            self._add_router(fastapi_app, get_home_router(self))
 
-        # Add middleware (only if app is not set)
         if not self._app_set:
 
-            @self.fastapi_app.exception_handler(HTTPException)
-            async def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
+            @fastapi_app.exception_handler(HTTPException)
+            async def http_exception_handler(_, exc: HTTPException) -> JSONResponse:
                 return JSONResponse(
                     status_code=exc.status_code,
                     content={"detail": str(exc.detail)},
@@ -284,12 +306,12 @@ class AgentOS:
                         content={"detail": str(e)},
                     )
 
-            self.fastapi_app.middleware("http")(general_exception_handler)
+            fastapi_app.middleware("http")(general_exception_handler)
 
         # Update CORS middleware
-        update_cors_middleware(self.fastapi_app, self.settings.cors_origin_list)  # type: ignore
+        update_cors_middleware(fastapi_app, self.settings.cors_origin_list)  # type: ignore
 
-        return self.fastapi_app
+        return fastapi_app
 
     def get_routes(self) -> List[Any]:
         """Retrieve all routes from the FastAPI app.
@@ -301,55 +323,37 @@ class AgentOS:
 
         return app.routes
 
-    def _get_existing_route_paths(self) -> Dict[str, List[str]]:
-        """Get all existing route paths and methods from the FastAPI app.
-
-        Returns:
-            Dict[str, List[str]]: Dictionary mapping paths to list of HTTP methods
-        """
-        if not self.fastapi_app:
-            return {}
-
-        existing_paths: Dict[str, Any] = {}
-        for route in self.fastapi_app.routes:
-            if isinstance(route, APIRoute):
-                path = route.path
-                methods = list(route.methods) if route.methods else []
-                if path in existing_paths:
-                    existing_paths[path].extend(methods)
-                else:
-                    existing_paths[path] = methods
-        return existing_paths
-
-    def _add_router(self, router: APIRouter) -> None:
+    def _add_router(self, fastapi_app: FastAPI, router: APIRouter) -> None:
         """Add a router to the FastAPI app, avoiding route conflicts.
 
         Args:
             router: The APIRouter to add
         """
-        if not self.fastapi_app:
-            return
 
-        # Get existing routes
-        existing_paths = self._get_existing_route_paths()
+        conflicts = find_conflicting_routes(fastapi_app, router)
+        conflicting_routes = [conflict["route"] for conflict in conflicts]
 
-        # Check for conflicts
-        conflicts = []
-        conflicting_routes = []
+        if conflicts and self._app_set:
+            if self.on_route_conflict == "preserve_base_app":
+                # Skip conflicting AgentOS routes, prefer user's existing routes
+                for conflict in conflicts:
+                    methods_str = ", ".join(conflict["methods"])  # type: ignore
+                    logger.debug(
+                        f"Skipping conflicting AgentOS route: {methods_str} {conflict['path']} - "
+                        f"Using existing custom route instead"
+                    )
 
-        for route in router.routes:
-            if isinstance(route, APIRoute):
-                full_path = route.path
-                route_methods = list(route.methods) if route.methods else []
+                # Create a new router without the conflicting routes
+                filtered_router = APIRouter()
+                for route in router.routes:
+                    if route not in conflicting_routes:
+                        filtered_router.routes.append(route)
 
-                if full_path in existing_paths:
-                    conflicting_methods: Set[str] = set(route_methods) & set(existing_paths[full_path])
-                    if conflicting_methods:
-                        conflicts.append({"path": full_path, "methods": list(conflicting_methods), "route": route})
-                        conflicting_routes.append(route)
+                # Use the filtered router if it has any routes left
+                if filtered_router.routes:
+                    fastapi_app.include_router(filtered_router)
 
-        if conflicts and self._app_set:
-            if self.replace_routes:
+            elif self.on_route_conflict == "preserve_agentos":
                 # Log warnings but still add all routes (AgentOS routes will override)
                 for conflict in conflicts:
                     methods_str = ", ".join(conflict["methods"])  # type: ignore
@@ -359,35 +363,21 @@ class AgentOS:
                     )
 
                 # Remove conflicting routes
-                for route in self.fastapi_app.routes:
+                for route in fastapi_app.routes:
                     for conflict in conflicts:
                         if isinstance(route, APIRoute):
                             if route.path == conflict["path"] and list(route.methods) == list(conflict["methods"]):  # type: ignore
-                                self.fastapi_app.routes.pop(self.fastapi_app.routes.index(route))
+                                fastapi_app.routes.pop(fastapi_app.routes.index(route))
 
-                self.fastapi_app.include_router(router)
+                fastapi_app.include_router(router)
 
-            else:
-                # Skip conflicting AgentOS routes, prefer user's existing routes
-                for conflict in conflicts:
-                    methods_str = ", ".join(conflict["methods"])  # type: ignore
-                    logger.debug(
-                        f"Skipping conflicting AgentOS route: {methods_str} {conflict['path']} - "
-                        f"Using existing custom route instead"
-                    )
+            elif self.on_route_conflict == "error":
+                conflicting_paths = [conflict["path"] for conflict in conflicts]
+                raise ValueError(f"Route conflict detected: {conflicting_paths}")
 
-                # Create a new router without the conflicting routes
-                filtered_router = APIRouter()
-                for route in router.routes:
-                    if route not in conflicting_routes:
-                        filtered_router.routes.append(route)
-
-                # Use the filtered router if it has any routes left
-                if filtered_router.routes:
-                    self.fastapi_app.include_router(filtered_router)
         else:
             # No conflicts, add router normally
-            self.fastapi_app.include_router(router)
+            fastapi_app.include_router(router)
 
     def _get_telemetry_data(self) -> Dict[str, Any]:
         """Get the telemetry data for the OS"""
@@ -398,57 +388,87 @@ class AgentOS:
             "interfaces": [interface.type for interface in self.interfaces] if self.interfaces else None,
         }
 
-    def _load_yaml_config(self, config_file_path: str) -> AgentOSConfig:
-        """Load a YAML config file and return the configuration as an AgentOSConfig instance."""
-        from pathlib import Path
-
-        import yaml
-
-        # Validate that the path points to a YAML file
-        path = Path(config_file_path)
-        if path.suffix.lower() not in [".yaml", ".yml"]:
-            raise ValueError(f"Config file must have a .yaml or .yml extension, got: {config_file_path}")
-
-        # Load the YAML file
-        with open(config_file_path, "r") as f:
-            return AgentOSConfig.model_validate(yaml.safe_load(f))
-
     def _auto_discover_databases(self) -> None:
         """Auto-discover the databases used by all contextual agents, teams and workflows."""
-        dbs = {}
-        knowledge_dbs = {}  # Track databases specifically used for knowledge
+        from agno.db.base import BaseDb
+
+        dbs: Dict[str, BaseDb] = {}
+        knowledge_dbs: Dict[str, BaseDb] = {}  # Track databases specifically used for knowledge
 
         for agent in self.agents or []:
             if agent.db:
-                dbs[agent.db.id] = agent.db
+                self._register_db_with_validation(dbs, agent.db)
             if agent.knowledge and agent.knowledge.contents_db:
-                knowledge_dbs[agent.knowledge.contents_db.id] = 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:
-                    dbs[agent.knowledge.contents_db.id] = agent.knowledge.contents_db
+                    self._register_db_with_validation(dbs, agent.knowledge.contents_db)
 
         for team in self.teams or []:
             if team.db:
-                dbs[team.db.id] = team.db
+                self._register_db_with_validation(dbs, team.db)
             if team.knowledge and team.knowledge.contents_db:
-                knowledge_dbs[team.knowledge.contents_db.id] = 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:
-                    dbs[team.knowledge.contents_db.id] = team.knowledge.contents_db
+                    self._register_db_with_validation(dbs, team.knowledge.contents_db)
 
         for workflow in self.workflows or []:
             if workflow.db:
-                dbs[workflow.db.id] = workflow.db
+                self._register_db_with_validation(dbs, workflow.db)
 
         for interface in self.interfaces or []:
             if interface.agent and interface.agent.db:
-                dbs[interface.agent.db.id] = interface.agent.db
+                self._register_db_with_validation(dbs, interface.agent.db)
             elif interface.team and interface.team.db:
-                dbs[interface.team.db.id] = interface.team.db
+                self._register_db_with_validation(dbs, interface.team.db)
 
         self.dbs = dbs
         self.knowledge_dbs = knowledge_dbs
 
+    def _register_db_with_validation(self, registered_dbs: Dict[str, Any], db: BaseDb) -> None:
+        """Register a database in the contextual OS after validating it is not conflicting with registered databases"""
+        if db.id in registered_dbs:
+            existing_db = registered_dbs[db.id]
+            if not self._are_db_instances_compatible(existing_db, db):
+                raise ValueError(
+                    f"Database ID conflict detected: Two different database instances have the same ID '{db.id}'. "
+                    f"Database instances with the same ID must point to the same database with identical configuration."
+                )
+        registered_dbs[db.id] = db
+
+    def _are_db_instances_compatible(self, db1: BaseDb, db2: BaseDb) -> bool:
+        """
+        Return True if the two given database objects are compatible
+        Two database objects are compatible if they point to the same database with identical configuration.
+        """
+        # If they're the same object reference, they're compatible
+        if db1 is db2:
+            return True
+
+        if type(db1) is not type(db2):
+            return False
+
+        if hasattr(db1, "db_url") and hasattr(db2, "db_url"):
+            if db1.db_url != db2.db_url:  # type: ignore
+                return False
+
+        if hasattr(db1, "db_file") and hasattr(db2, "db_file"):
+            if db1.db_file != db2.db_file:  # type: ignore
+                return False
+
+        # If table names are different, they're not compatible
+        if (
+            db1.session_table_name != db2.session_table_name
+            or db1.memory_table_name != db2.memory_table_name
+            or db1.metrics_table_name != db2.metrics_table_name
+            or db1.eval_table_name != db2.eval_table_name
+            or db1.knowledge_table_name != db2.knowledge_table_name
+        ):
+            return False
+
+        return True
+
     def _auto_discover_knowledge_instances(self) -> None:
         """Auto-discover the knowledge instances used by all contextual agents, teams and workflows."""
         knowledge_instances = []
@@ -594,11 +614,10 @@ class AgentOS:
         from rich.align import Align
         from rich.console import Console, Group
 
-        panel_group = []
-        panel_group.append(Align.center(f"[bold cyan]{public_endpoint}[/bold cyan]"))
-        panel_group.append(
-            Align.center(f"\n\n[bold dark_orange]OS running on:[/bold dark_orange] http://{host}:{port}")
-        )
+        panel_group = [
+            Align.center(f"[bold cyan]{public_endpoint}[/bold cyan]"),
+            Align.center(f"\n\n[bold dark_orange]OS running on:[/bold dark_orange] http://{host}:{port}"),
+        ]
         if bool(self.settings.os_security_key):
             panel_group.append(Align.center("\n\n[bold chartreuse3]:lock: Security Enabled[/bold chartreuse3]"))
 

agno/os/interfaces/whatsapp/router.py

@@ -123,6 +123,7 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
                 response = await agent.arun(
                     message_text,
                     user_id=phone_number,
+                    session_id=f"wa:{phone_number}",
                     images=[Image(content=await get_media_async(message_image))] if message_image else None,
                     files=[File(content=await get_media_async(message_doc))] if message_doc else None,
                     videos=[Video(content=await get_media_async(message_video))] if message_video else None,
@@ -132,6 +133,7 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
                 response = await team.arun(  # type: ignore
                     message_text,
                     user_id=phone_number,
+                    session_id=f"wa:{phone_number}",
                     files=[File(content=await get_media_async(message_doc))] if message_doc else None,
                     images=[Image(content=await get_media_async(message_image))] if message_image else None,
                     videos=[Video(content=await get_media_async(message_video))] if message_video else None,

agno/os/mcp.py

@@ -54,7 +54,7 @@ def get_mcp_server(
     )  # type: ignore
     async def config() -> ConfigResponse:
         return ConfigResponse(
-            os_id=os.os_id or "AgentOS",
+            os_id=os.id or "AgentOS",
             description=os.description,
             available_models=os.config.available_models if os.config else [],
             databases=[db.id for db in os.dbs.values()],

agno/os/middleware/__init__.py

@@ -0,0 +1,7 @@
+from agno.os.middleware.jwt import (
+    JWTMiddleware,
+)
+
+__all__ = [
+    "JWTMiddleware",
+]