agno 2.3.26__py3-none-any.whl → 2.4.1__py3-none-any.whl

agno/models/response.py

@@ -16,6 +16,10 @@ class ModelResponseEvent(str, Enum):
     tool_call_started = "ToolCallStarted"
     tool_call_completed = "ToolCallCompleted"
     assistant_response = "AssistantResponse"
+    compression_started = "CompressionStarted"
+    compression_completed = "CompressionCompleted"
+    model_request_started = "ModelRequestStarted"
+    model_request_completed = "ModelRequestCompleted"
 
 
 @dataclass
@@ -124,6 +128,18 @@ class ModelResponse:
 
     updated_session_state: Optional[Dict[str, Any]] = None
 
+    # Compression stats
+    compression_stats: Optional[Dict[str, Any]] = None
+
+    # Model request metrics (for model_request_completed events)
+    input_tokens: Optional[int] = None
+    output_tokens: Optional[int] = None
+    total_tokens: Optional[int] = None
+    time_to_first_token: Optional[float] = None
+    reasoning_tokens: Optional[int] = None
+    cache_read_tokens: Optional[int] = None
+    cache_write_tokens: Optional[int] = None
+
     def to_dict(self) -> Dict[str, Any]:
         """Serialize ModelResponse to dictionary for caching."""
         _dict = asdict(self)

agno/os/app.py

@@ -36,6 +36,7 @@ from agno.os.config import (
 from agno.os.interfaces.base import BaseInterface
 from agno.os.router import get_base_router, get_websocket_router
 from agno.os.routers.agents import get_agent_router
+from agno.os.routers.components import get_components_router
 from agno.os.routers.database import get_database_router
 from agno.os.routers.evals import get_eval_router
 from agno.os.routers.health import get_health_router
@@ -43,6 +44,7 @@ from agno.os.routers.home import get_home_router
 from agno.os.routers.knowledge import get_knowledge_router
 from agno.os.routers.memory import get_memory_router
 from agno.os.routers.metrics import get_metrics_router
+from agno.os.routers.registry import get_registry_router
 from agno.os.routers.session import get_session_router
 from agno.os.routers.teams import get_team_router
 from agno.os.routers.traces import get_traces_router
@@ -57,6 +59,7 @@ from agno.os.utils import (
     setup_tracing_for_os,
     update_cors_middleware,
 )
+from agno.registry import Registry
 from agno.remote.base import RemoteDb, RemoteKnowledge
 from agno.team import RemoteTeam, Team
 from agno.utils.log import log_debug, log_error, log_info, log_warning
@@ -129,6 +132,7 @@ class AgentOS:
         name: Optional[str] = None,
         description: Optional[str] = None,
         version: Optional[str] = None,
+        db: Optional[Union[BaseDb, AsyncBaseDb]] = None,
         agents: Optional[List[Union[Agent, RemoteAgent]]] = None,
         teams: Optional[List[Union[Team, RemoteTeam]]] = None,
         workflows: Optional[List[Union[Workflow, RemoteWorkflow]]] = None,
@@ -145,10 +149,10 @@ class AgentOS:
         base_app: Optional[FastAPI] = None,
         on_route_conflict: Literal["preserve_agentos", "preserve_base_app", "error"] = "preserve_agentos",
         tracing: bool = False,
-        tracing_db: Optional[Union[BaseDb, AsyncBaseDb]] = None,
         auto_provision_dbs: bool = True,
         run_hooks_in_background: bool = False,
         telemetry: bool = True,
+        registry: Optional[Registry] = None,
     ):
         """Initialize AgentOS.
 
@@ -157,6 +161,7 @@ class AgentOS:
             name: Name of the AgentOS instance
             description: Description of the AgentOS instance
             version: Version of the AgentOS instance
+            db: Default database for the AgentOS instance. Agents, teams and workflows with no db will use this one.
             agents: List of agents to include in the OS
             teams: List of teams to include in the OS
             workflows: List of workflows to include in the OS
@@ -174,14 +179,13 @@ class AgentOS:
             authorization_config: Configuration for the authorization middleware
             cors_allowed_origins: List of allowed CORS origins (will be merged with default Agno domains)
             tracing: If True, enables OpenTelemetry tracing for all agents and teams in the OS
-            tracing_db: Dedicated database for storing and reading traces. Recommended for multi-db setups.
-                       If not provided and tracing=True, the first available db from agents/teams/workflows is used.
             run_hooks_in_background: If True, run agent/team pre/post hooks as FastAPI background tasks (non-blocking)
             telemetry: Whether to enable telemetry
+            registry: Optional registry to use for the AgentOS
 
         """
-        if not agents and not workflows and not teams and not knowledge:
-            raise ValueError("Either agents, teams, workflows or knowledge bases must be provided.")
+        if not agents and not workflows and not teams and not knowledge and not db:
+            raise ValueError("Either agents, teams, workflows, knowledge bases or a database must be provided.")
 
         self.config = load_yaml_config(config) if isinstance(config, str) else config
 
@@ -214,14 +218,16 @@ class AgentOS:
 
         self.version = version
         self.description = description
+        self.db = db
 
         self.telemetry = telemetry
         self.tracing = tracing
-        self.tracing_db = tracing_db
 
         self.enable_mcp_server = enable_mcp_server
         self.lifespan = lifespan
 
+        self.registry = registry
+
         # RBAC
         self.authorization = authorization
         self.authorization_config = authorization_config
@@ -309,6 +315,12 @@ class AgentOS:
             get_traces_router(dbs=self.dbs),
             get_database_router(self, settings=self.settings),
         ]
+        # Add component and registry routers only if a sync db (BaseDb) is available
+        # Component routes require sync database operations
+        if self.db is not None and isinstance(self.db, BaseDb):
+            updated_routers.append(get_components_router(os_db=self.db, registry=self.registry))
+        if self.registry is not None:
+            updated_routers.append(get_registry_router(registry=self.registry))
 
         # Clear all previously existing routes
         app.router.routes = [
@@ -338,8 +350,8 @@ class AgentOS:
 
         self._add_router(app, get_health_router(health_endpoint="/health"))
         self._add_router(app, get_base_router(self, settings=self.settings))
-        self._add_router(app, get_agent_router(self, settings=self.settings))
-        self._add_router(app, get_team_router(self, settings=self.settings))
+        self._add_router(app, get_agent_router(self, settings=self.settings, registry=self.registry))
+        self._add_router(app, get_team_router(self, settings=self.settings, registry=self.registry))
         self._add_router(app, get_workflow_router(self, settings=self.settings))
         self._add_router(app, get_websocket_router(self, settings=self.settings))
 
@@ -418,6 +430,9 @@ class AgentOS:
         for agent in self.agents:
             if isinstance(agent, RemoteAgent):
                 continue
+            # Set the default db to agents without their own
+            if self.db is not None and agent.db is None:
+                agent.db = self.db
             # Track all MCP tools to later handle their connection
             if agent.tools:
                 for tool in agent.tools:
@@ -444,6 +459,11 @@ class AgentOS:
         for team in self.teams:
             if isinstance(team, RemoteTeam):
                 continue
+
+            # Set the default db to teams without their own
+            if self.db is not None and team.db is None:
+                team.db = self.db
+
             # Track all MCP tools recursively
             collect_mcp_tools_from_team(team, self.mcp_tools)
 
@@ -467,31 +487,34 @@ class AgentOS:
         if not self.workflows:
             return
 
-        if self.workflows:
-            for workflow in self.workflows:
-                if isinstance(workflow, RemoteWorkflow):
-                    continue
-                # Track MCP tools recursively in workflow members
-                collect_mcp_tools_from_workflow(workflow, self.mcp_tools)
+        for workflow in self.workflows:
+            if isinstance(workflow, RemoteWorkflow):
+                continue
+            # Set the default db to workflows without their own
+            if self.db is not None and workflow.db is None:
+                workflow.db = self.db
 
-                if not workflow.id:
-                    workflow.id = generate_id_from_name(workflow.name)
+            # Track MCP tools recursively in workflow members
+            collect_mcp_tools_from_workflow(workflow, self.mcp_tools)
 
-                # Required for the built-in routes to work
-                workflow.store_events = True
+            if not workflow.id:
+                workflow.id = generate_id_from_name(workflow.name)
 
-                # Propagate run_hooks_in_background setting to workflow and all its step agents/teams
-                workflow.propagate_run_hooks_in_background(self.run_hooks_in_background)
+            # Required for the built-in routes to work
+            workflow.store_events = True
+
+            # Propagate run_hooks_in_background setting to workflow and all its step agents/teams
+            workflow.propagate_run_hooks_in_background(self.run_hooks_in_background)
 
     def _setup_tracing(self) -> None:
         """Set up OpenTelemetry tracing for this AgentOS.
 
-        Uses tracing_db if provided, otherwise falls back to the first available
+        Uses the AgentOS db if provided, otherwise falls back to the first available
         database from agents/teams/workflows.
         """
-        # Use tracing_db if explicitly provided
-        if self.tracing_db is not None:
-            setup_tracing_for_os(db=self.tracing_db)
+        # Use AgentOS db if explicitly provided
+        if self.db is not None:
+            setup_tracing_for_os(db=self.db)
             return
 
         # Fall back to finding the first available database
@@ -517,7 +540,7 @@ class AgentOS:
         if db is None:
             log_warning(
                 "tracing=True but no database found. "
-                "Provide 'tracing_db' parameter or 'db' parameter to at least one agent/team/workflow."
+                "Provide 'db' parameter to AgentOS or to at least one agent/team/workflow."
             )
             return
 
@@ -605,6 +628,12 @@ class AgentOS:
             get_traces_router(dbs=self.dbs),
             get_database_router(self, settings=self.settings),
         ]
+        # Add component and registry routers only if a sync db (BaseDb) is available
+        # Component routes require sync database operations
+        if self.db is not None and isinstance(self.db, BaseDb):
+            routers.append(get_components_router(os_db=self.db, registry=self.registry))
+        if self.registry is not None:
+            routers.append(get_registry_router(registry=self.registry))
 
         for router in routers:
             self._add_router(fastapi_app, router)
@@ -676,6 +705,11 @@ class AgentOS:
 
             self._add_jwt_middleware(fastapi_app)
 
+        # Add trailing slash normalization middleware
+        from agno.os.middleware.trailing_slash import TrailingSlashMiddleware
+
+        fastapi_app.add_middleware(TrailingSlashMiddleware)
+
         return fastapi_app
 
     def _add_jwt_middleware(self, fastapi_app: FastAPI) -> None:
@@ -807,14 +841,16 @@ class AgentOS:
         for agent in self.agents or []:
             if agent.db:
                 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)
+            agent_contents_db = getattr(agent.knowledge, "contents_db", None) if agent.knowledge else None
+            if agent_contents_db:
+                self._register_db_with_validation(knowledge_dbs, agent_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)
+            team_contents_db = getattr(team.knowledge, "contents_db", None) if team.knowledge else None
+            if team_contents_db:
+                self._register_db_with_validation(knowledge_dbs, team_contents_db)
 
         for workflow in self.workflows or []:
             if workflow.db:
@@ -830,9 +866,9 @@ class AgentOS:
             elif interface.team and interface.team.db:
                 self._register_db_with_validation(dbs, interface.team.db)
 
-        # Register tracing_db if provided (for traces reading)
-        if self.tracing_db is not None:
-            self._register_db_with_validation(dbs, self.tracing_db)
+        # Register AgentOS db if provided
+        if self.db is not None:
+            self._register_db_with_validation(dbs, self.db)
 
         self.dbs = dbs
         self.knowledge_dbs = knowledge_dbs
@@ -939,18 +975,21 @@ class AgentOS:
 
     def _auto_discover_knowledge_instances(self) -> None:
         """Auto-discover the knowledge instances used by all contextual agents, teams and workflows."""
-        seen_ids = set()
+        seen_ids: set[str] = set()
         knowledge_instances: List[Union[Knowledge, RemoteKnowledge]] = []
 
-        def _add_knowledge_if_not_duplicate(knowledge: Union["Knowledge", RemoteKnowledge]) -> None:
+        def _add_knowledge_if_not_duplicate(knowledge: Any) -> None:
             """Add knowledge instance if it's not already in the list (by object identity or db_id)."""
-            # Use database ID if available, otherwise use object ID as fallback
-            if not knowledge.contents_db:
+            # Only handle Knowledge and RemoteKnowledge instances that have contents_db
+            contents_db = getattr(knowledge, "contents_db", None)
+            if not contents_db:
                 return
-            if knowledge.contents_db.id in seen_ids:
+            if contents_db.id in seen_ids:
                 return
-            seen_ids.add(knowledge.contents_db.id)
-            knowledge_instances.append(knowledge)
+            seen_ids.add(contents_db.id)
+            # Only append if it's a Knowledge or RemoteKnowledge instance
+            if isinstance(knowledge, (Knowledge, RemoteKnowledge)):
+                knowledge_instances.append(knowledge)
 
         for agent in self.agents or []:
             if agent.knowledge:
@@ -1080,13 +1119,13 @@ class AgentOS:
 
         dbs_with_specific_config = [db.db_id for db in traces_config.dbs]
 
-        # If tracing_db is explicitly set, only use that database for traces
-        if self.tracing_db is not None:
-            if self.tracing_db.id not in dbs_with_specific_config:
+        # If AgentOS db is explicitly set, only use that database for traces
+        if self.db is not None:
+            if self.db.id not in dbs_with_specific_config:
                 traces_config.dbs.append(
                     DatabaseConfig(
-                        db_id=self.tracing_db.id,
-                        domain_config=TracesDomainConfig(display_name=self.tracing_db.id),
+                        db_id=self.db.id,
+                        domain_config=TracesDomainConfig(display_name=self.db.id),
                     )
                 )
         else:

agno/os/interfaces/slack/router.py

@@ -7,7 +7,7 @@ from agno.agent import Agent, RemoteAgent
 from agno.os.interfaces.slack.security import verify_slack_signature
 from agno.team import RemoteTeam, Team
 from agno.tools.slack import SlackTools
-from agno.utils.log import log_info
+from agno.utils.log import log_error, log_info
 from agno.workflow import RemoteWorkflow, Workflow
 
 
@@ -112,6 +112,15 @@ def attach_routes(
             response = await workflow.arun(message_text, user_id=user, session_id=session_id)  # type: ignore
 
         if response:
+            if response.status == "ERROR":
+                log_error(f"Error processing message: {response.content}")
+                _send_slack_message(
+                    channel=channel_id,
+                    message="Sorry, there was an error processing your message. Please try again later.",
+                    thread_ts=ts,
+                )
+                return
+
             if hasattr(response, "reasoning_content") and response.reasoning_content:
                 _send_slack_message(
                     channel=channel_id,

agno/os/interfaces/whatsapp/router.py

@@ -162,6 +162,12 @@ def attach_routes(
                     videos=[Video(content=await get_media_async(message_video))] if message_video else None,
                     audio=[Audio(content=await get_media_async(message_audio))] if message_audio else None,
                 )
+            if response.status == "ERROR":
+                await _send_whatsapp_message(
+                    phone_number, "Sorry, there was an error processing your message. Please try again later."
+                )
+                log_error(response.content)
+                return
 
             if response.reasoning_content:
                 await _send_whatsapp_message(phone_number, f"Reasoning: \n{response.reasoning_content}", italics=True)

agno/os/middleware/__init__.py

@@ -2,8 +2,10 @@ from agno.os.middleware.jwt import (
     JWTMiddleware,
     TokenSource,
 )
+from agno.os.middleware.trailing_slash import TrailingSlashMiddleware
 
 __all__ = [
     "JWTMiddleware",
     "TokenSource",
+    "TrailingSlashMiddleware",
 ]

agno/os/middleware/trailing_slash.py

@@ -0,0 +1,27 @@
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import Response
+
+
+class TrailingSlashMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware that strips trailing slashes from request paths.
+
+    This ensures that both /agents and /agents/ are handled identically
+    without requiring a redirect. Updates both 'path' and 'raw_path'
+    """
+
+    async def dispatch(self, request: Request, call_next) -> Response:
+        # Get the path from the request scope
+        path = request.scope.get("path", "")
+
+        # Strip trailing slash if path is not root "/"
+        if path != "/" and path.endswith("/"):
+            normalized_path = path.rstrip("/")
+            if normalized_path:  # Ensure we don't end up with empty path
+                # Modify the scope to remove trailing slash
+                request.scope["path"] = normalized_path
+                # Update raw_path for ASGI spec compliance
+                request.scope["raw_path"] = normalized_path.encode("utf-8")
+
+        return await call_next(request)

agno/os/router.py

@@ -165,6 +165,7 @@ def get_base_router(
             os_id=os.id or "Unnamed OS",
             description=os.description,
             available_models=os.config.available_models if os.config else [],
+            os_database=os.db.id if os.db else None,
             databases=list({db.id for db_id, dbs in os.dbs.items() for db in dbs}),
             chat=os.config.chat if os.config else None,
             session=os._get_session_config(),

agno/os/routers/agents/router.py

@@ -16,6 +16,7 @@ from fastapi.responses import JSONResponse, StreamingResponse
 
 from agno.agent.agent import Agent
 from agno.agent.remote import RemoteAgent
+from agno.db.base import BaseDb
 from agno.exceptions import InputCheckError, OutputCheckError
 from agno.media import Audio, Image, Video
 from agno.media import File as FileMedia
@@ -38,6 +39,7 @@ from agno.os.utils import (
     process_image,
     process_video,
 )
+from agno.registry import Registry
 from agno.run.agent import RunErrorEvent, RunOutput
 from agno.utils.log import log_debug, log_error, log_warning
 
@@ -156,6 +158,7 @@ async def agent_continue_response_streamer(
 def get_agent_router(
     os: "AgentOS",
     settings: AgnoAPISettings = AgnoAPISettings(),
+    registry: Optional[Registry] = None,
 ) -> APIRouter:
     """
     Create the agent router with comprehensive OpenAPI documentation.
@@ -216,6 +219,7 @@ def get_agent_router(
         session_id: Optional[str] = Form(None),
         user_id: Optional[str] = Form(None),
         files: Optional[List[UploadFile]] = File(None),
+        version: Optional[str] = Form(None),
     ):
         kwargs = await get_request_kwargs(request, create_agent_run)
 
@@ -243,7 +247,9 @@ def get_agent_router(
                 log_warning("Metadata parameter passed in both request state and kwargs, using request state")
             kwargs["metadata"] = metadata
 
-        agent = get_agent_by_id(agent_id, os.agents, create_fresh=True)
+        agent = get_agent_by_id(
+            agent_id, os.agents, os.db, registry, version=int(version) if version else None, create_fresh=True
+        )
         if agent is None:
             raise HTTPException(status_code=404, detail="Agent not found")
 
@@ -405,7 +411,7 @@ def get_agent_router(
         agent_id: str,
         run_id: str,
     ):
-        agent = get_agent_by_id(agent_id, os.agents, create_fresh=True)
+        agent = get_agent_by_id(agent_id=agent_id, agents=os.agents, db=os.db, registry=os.registry, create_fresh=True)
         if agent is None:
             raise HTTPException(status_code=404, detail="Agent not found")
 
@@ -464,7 +470,7 @@ def get_agent_router(
         except json.JSONDecodeError:
             raise HTTPException(status_code=400, detail="Invalid JSON in tools field")
 
-        agent = get_agent_by_id(agent_id, os.agents, create_fresh=True)
+        agent = get_agent_by_id(agent_id=agent_id, agents=os.agents, db=os.db, registry=os.registry, create_fresh=True)
         if agent is None:
             raise HTTPException(status_code=404, detail="Agent not found")
 
@@ -563,9 +569,6 @@ def get_agent_router(
     )
     async def get_agents(request: Request) -> List[AgentResponse]:
         """Return the list of all Agents present in the contextual OS"""
-        if os.agents is None:
-            return []
-
         # Filter agents based on user's scopes (only if authorization is enabled)
         if getattr(request.state, "authorization_enabled", False):
             from agno.os.auth import filter_resources_by_access, get_accessible_resources
@@ -576,17 +579,27 @@ def get_agent_router(
                 raise HTTPException(status_code=403, detail="Insufficient permissions")
 
             # Limit results based on the user's access/scopes
-            accessible_agents = filter_resources_by_access(request, os.agents, "agents")
+            accessible_agents = filter_resources_by_access(request, os.agents or [], "agents")
         else:
-            accessible_agents = os.agents
+            accessible_agents = os.agents or []
+
+        agents: List[AgentResponse] = []
+        if accessible_agents:
+            for agent in accessible_agents:
+                if isinstance(agent, RemoteAgent):
+                    agents.append(await agent.get_agent_config())
+                else:
+                    agent_response = await AgentResponse.from_agent(agent=agent)
+                    agents.append(agent_response)
+
+        if os.db and isinstance(os.db, BaseDb):
+            from agno.agent.agent import get_agents
 
-        agents = []
-        for agent in accessible_agents:
-            if isinstance(agent, RemoteAgent):
-                agents.append(await agent.get_agent_config())
-            else:
-                agent_response = await AgentResponse.from_agent(agent=agent)
-                agents.append(agent_response)
+            db_agents = get_agents(db=os.db, registry=registry)
+            if db_agents:
+                for db_agent in db_agents:
+                    agent_response = await AgentResponse.from_agent(agent=db_agent)
+                    agents.append(agent_response)
 
         return agents
 
@@ -630,7 +643,7 @@ def get_agent_router(
         dependencies=[Depends(require_resource_access("agents", "read", "agent_id"))],
     )
     async def get_agent(agent_id: str, request: Request) -> AgentResponse:
-        agent = get_agent_by_id(agent_id, os.agents, create_fresh=True)
+        agent = get_agent_by_id(agent_id=agent_id, agents=os.agents, db=os.db, registry=os.registry, create_fresh=True)
         if agent is None:
             raise HTTPException(status_code=404, detail="Agent not found")
 

agno/os/routers/agents/schema.py

@@ -65,7 +65,7 @@ class AgentResponse(BaseModel):
             "enable_agentic_knowledge_filters": False,
             # Memory defaults
             "enable_agentic_memory": False,
-            "enable_user_memories": False,
+            "update_memory_on_run": False,
             # Reasoning defaults
             "reasoning": False,
             "reasoning_min_steps": 1,
@@ -151,8 +151,9 @@ class AgentResponse(BaseModel):
             "cache_session": agent.cache_session,
         }
 
+        contents_db = getattr(agent.knowledge, "contents_db", None) if agent.knowledge else None
         knowledge_info = {
-            "db_id": agent.knowledge.contents_db.id if agent.knowledge and agent.knowledge.contents_db else None,
+            "db_id": contents_db.id if contents_db else None,
             "knowledge_table": knowledge_table,
             "enable_agentic_knowledge_filters": agent.enable_agentic_knowledge_filters,
             "knowledge_filters": agent.knowledge_filters,
@@ -163,9 +164,10 @@ class AgentResponse(BaseModel):
         if agent.memory_manager is not None:
             memory_info = {
                 "enable_agentic_memory": agent.enable_agentic_memory,
-                "enable_user_memories": agent.enable_user_memories,
+                "update_memory_on_run": agent.update_memory_on_run,
+                "enable_user_memories": agent.enable_user_memories,  # Soon to be deprecated. Use update_memory_on_run
                 "metadata": agent.metadata,
-                "memory_table": agent.db.memory_table_name if agent.db and agent.enable_user_memories else None,
+                "memory_table": agent.db.memory_table_name if agent.db and agent.update_memory_on_run else None,
             }
 
             if agent.memory_manager.model is not None:

agno/os/routers/components/__init__.py

@@ -0,0 +1,3 @@
+from agno.os.routers.components.components import get_components_router
+
+__all__ = ["get_components_router"]