Merge branch 'main' into release/v2.2.4

Author: manuhortet

cookbook/agent_os/update_from_lifespan.py

@@ -0,0 +1,46 @@
+from contextlib import asynccontextmanager
+
+from agno.agent.agent import Agent
+from agno.db.postgres import PostgresDb
+from agno.os import AgentOS
+
+# First agent. We will add this to the AgentOS on initialization.
+agent1 = Agent(
+    id="first-agent",
+    name="First Agent",
+    markdown=True,
+)
+
+# Second agent. We will add this to the AgentOS in the lifespan function.
+agent2 = Agent(
+    id="second-agent",
+    name="Second Agent",
+    markdown=True,
+    db=PostgresDb(db_url="postgresql+psycopg://ai:ai@localhost:5532/ai"),
+)
+
+
+# Lifespan function receiving the AgentOS instance as parameter.
+@asynccontextmanager
+async def lifespan(app, agent_os):
+    # Add the new Agent
+    agent_os.agents.append(agent2)
+
+    # Resync the AgentOS
+    agent_os.resync()
+
+    yield
+
+
+# Setup our AgentOS with the lifespan function and the first agent.
+agent_os = AgentOS(
+    lifespan=lifespan,
+    agents=[agent1],
+)
+
+# Get our app.
+app = agent_os.get_app()
+
+# Serve the app.
+if __name__ == "__main__":
+    agent_os.serve(app="update_from_lifespan:app", reload=True)

libs/agno/agno/os/app.py

@@ -187,54 +187,50 @@ def __init__(
         self.mcp_tools: List[Any] = []
         self._mcp_app: Optional[Any] = None
 
-        if self.agents:
-            for agent in self.agents:
-                # Track all MCP tools to later handle their connection
-                if agent.tools:
-                    for tool in agent.tools:
-                        # Checking if the tool is a MCPTools or MultiMCPTools instance
-                        type_name = type(tool).__name__
-                        if type_name in ("MCPTools", "MultiMCPTools"):
-                            if tool not in self.mcp_tools:
-                                self.mcp_tools.append(tool)
-
-                agent.initialize_agent()
+        self._initialize_agents()
+        self._initialize_teams()
+        self._initialize_workflows()
 
-                # Required for the built-in routes to work
-                agent.store_events = True
-
-        if self.teams:
-            for team in self.teams:
-                # Track all MCP tools recursively
-                collect_mcp_tools_from_team(team, self.mcp_tools)
+        if self.telemetry:
+            from agno.api.os import OSLaunch, log_os_telemetry
 
-                team.initialize_team()
+            log_os_telemetry(launch=OSLaunch(os_id=self.id, data=self._get_telemetry_data()))
 
-                for member in team.members:
-                    if isinstance(member, Agent):
-                        member.team_id = None
-                        member.initialize_agent()
-                    elif isinstance(member, Team):
-                        member.initialize_team()
+    def _add_agent_os_to_lifespan_function(self, lifespan):
+        """
+        Inspect a lifespan function and wrap it to pass agent_os if it accepts it.
 
-                # Required for the built-in routes to work
-                team.store_events = True
+        Returns:
+            A wrapped lifespan that passes agent_os if the lifespan function expects it.
+        """
+        # Getting the actual function inside the lifespan
+        lifespan_function = lifespan
+        if hasattr(lifespan, "__wrapped__"):
+            lifespan_function = lifespan.__wrapped__
 
-        if self.workflows:
-            for workflow in self.workflows:
-                # Track MCP tools recursively in workflow members
-                collect_mcp_tools_from_workflow(workflow, self.mcp_tools)
+        try:
+            from inspect import signature
 
-                if not workflow.id:
-                    workflow.id = generate_id_from_name(workflow.name)
+            # Inspecting the lifespan function signature to find its parameters
+            sig = signature(lifespan_function)
+            params = list(sig.parameters.keys())
 
-                # Required for the built-in routes to work
-                workflow.store_events = True
+            # If the lifespan function expects the 'agent_os' parameter, add it
+            if "agent_os" in params:
+                return partial(lifespan, agent_os=self)
+            else:
+                return lifespan
 
-        if self.telemetry:
-            from agno.api.os import OSLaunch, log_os_telemetry
+        except (ValueError, TypeError):
+            return lifespan
 
-            log_os_telemetry(launch=OSLaunch(os_id=self.id, data=self._get_telemetry_data()))
+    def resync(self) -> None:
+        """Resync the AgentOS to discover, initialize and configure: agents, teams, workflows, databases and knowledge bases."""
+        self._initialize_agents()
+        self._initialize_teams()
+        self._initialize_workflows()
+        self._auto_discover_databases()
+        self._auto_discover_knowledge_instances()
 
     def _make_app(self, lifespan: Optional[Any] = None) -> FastAPI:
         # Adjust the FastAPI app lifespan to handle MCP connections if relevant
@@ -265,6 +261,63 @@ async def combined_lifespan(app: FastAPI):
             lifespan=app_lifespan,
         )
 
+    def _initialize_agents(self) -> None:
+        """Initialize and configure all agents for AgentOS usage."""
+        if not self.agents:
+            return
+
+        for agent in self.agents:
+            # Track all MCP tools to later handle their connection
+            if agent.tools:
+                for tool in agent.tools:
+                    # Checking if the tool is a MCPTools or MultiMCPTools instance
+                    type_name = type(tool).__name__
+                    if type_name in ("MCPTools", "MultiMCPTools"):
+                        if tool not in self.mcp_tools:
+                            self.mcp_tools.append(tool)
+
+            agent.initialize_agent()
+
+            # Required for the built-in routes to work
+            agent.store_events = True
+
+    def _initialize_teams(self) -> None:
+        """Initialize and configure all teams for AgentOS usage."""
+        if not self.teams:
+            return
+
+        for team in self.teams:
+            # Track all MCP tools recursively
+            collect_mcp_tools_from_team(team, self.mcp_tools)
+
+            team.initialize_team()
+
+            for member in team.members:
+                if isinstance(member, Agent):
+                    member.team_id = None
+                    member.initialize_agent()
+                elif isinstance(member, Team):
+                    member.initialize_team()
+
+            # Required for the built-in routes to work
+            team.store_events = True
+
+    def _initialize_workflows(self) -> None:
+        """Initialize and configure all workflows for AgentOS usage."""
+        if not self.workflows:
+            return
+
+        if self.workflows:
+            for workflow in self.workflows:
+                # 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)
+
+                # Required for the built-in routes to work
+                workflow.store_events = True
+
     def get_app(self) -> FastAPI:
         if self.base_app:
             fastapi_app = self.base_app
@@ -288,7 +341,9 @@ def get_app(self) -> FastAPI:
                 lifespans.append(self._mcp_app.lifespan)
 
             if self.lifespan:
-                lifespans.append(self.lifespan)
+                # Wrap the user lifespan with agent_os parameter
+                wrapped_lifespan = self._add_agent_os_to_lifespan_function(self.lifespan)
+                lifespans.append(wrapped_lifespan)
 
             # Combine lifespans and set them in the app
             if lifespans:
@@ -304,19 +359,27 @@ def get_app(self) -> FastAPI:
 
                 final_lifespan = self._mcp_app.lifespan  # type: ignore
                 if self.lifespan is not None:
+                    # Wrap the user lifespan with agent_os parameter
+                    wrapped_lifespan = self._add_agent_os_to_lifespan_function(self.lifespan)
+
                     # Combine both lifespans
                     @asynccontextmanager
                     async def combined_lifespan(app: FastAPI):
                         # Run both lifespans
-                        async with self.lifespan(app):  # type: ignore
+                        async with wrapped_lifespan(app):  # type: ignore
                             async with self._mcp_app.lifespan(app):  # type: ignore
                                 yield
 
                     final_lifespan = combined_lifespan  # type: ignore
 
                 fastapi_app = self._make_app(lifespan=final_lifespan)
             else:
-                fastapi_app = self._make_app(lifespan=self.lifespan)
+                # Wrap the user lifespan with agent_os parameter
+                wrapped_user_lifespan = None
+                if self.lifespan is not None:
+                    wrapped_user_lifespan = self._add_agent_os_to_lifespan_function(self.lifespan)
+
+                fastapi_app = self._make_app(lifespan=wrapped_user_lifespan)
 
         # Add routes
         self._add_router(fastapi_app, get_base_router(self, settings=self.settings))