agno 2.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/os/interfaces/slack/router.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, Union
 
 from fastapi import APIRouter, BackgroundTasks, HTTPException, Request
 from pydantic import BaseModel, Field
@@ -24,19 +24,21 @@ class SlackChallengeResponse(BaseModel):
 
 
 def attach_routes(
-    router: APIRouter, agent: Optional[Agent] = None, team: Optional[Team] = None, workflow: Optional[Workflow] = None
+    router: APIRouter,
+    agent: Optional[Agent] = None,
+    team: Optional[Team] = None,
+    workflow: Optional[Workflow] = None,
+    reply_to_mentions_only: bool = True,
 ) -> APIRouter:
     # Determine entity type for documentation
     entity_type = "agent" if agent else "team" if team else "workflow" if workflow else "unknown"
-    entity_name = getattr(agent or team or workflow, "name", f"Unnamed {entity_type}")
 
     @router.post(
         "/events",
         operation_id=f"slack_events_{entity_type}",
-        summary=f"Process Slack Events for {entity_type.title()}",
-        description=f"Process incoming Slack events and route them to the configured {entity_type}: {entity_name}",
-        tags=["Slack", f"Slack-{entity_type.title()}"],
-        response_model=SlackEventResponse,
+        name="slack_events",
+        description="Process incoming Slack events",
+        response_model=Union[SlackChallengeResponse, SlackEventResponse],
         response_model_exclude_none=True,
         responses={
             200: {"description": "Event processed successfully"},
@@ -73,36 +75,52 @@ def attach_routes(
         return SlackEventResponse(status="ok")
 
     async def _process_slack_event(event: dict):
-        if event.get("type") == "message":
-            user = None
-            message_text = event.get("text", "")
-            channel_id = event.get("channel", "")
-            user = event.get("user")
-            if event.get("thread_ts"):
-                ts = event.get("thread_ts", "")
-            else:
-                ts = event.get("ts", "")
-
-            # Use the timestamp as the session id, so that each thread is a separate session
-            session_id = ts
-
-            if agent:
-                response = await agent.arun(message_text, user_id=user if user else None, session_id=session_id)
-            elif team:
-                response = await team.arun(message_text, user_id=user if user else None, session_id=session_id)  # type: ignore
-            elif workflow:
-                response = await workflow.arun(message_text, user_id=user if user else None, session_id=session_id)  # type: ignore
-
-            if response:
-                if hasattr(response, "reasoning_content") and response.reasoning_content:
-                    _send_slack_message(
-                        channel=channel_id,
-                        message=f"Reasoning: \n{response.reasoning_content}",
-                        thread_ts=ts,
-                        italics=True,
-                    )
-
-                _send_slack_message(channel=channel_id, message=response.content or "", thread_ts=ts)
+        event_type = event.get("type")
+
+        # Only handle app_mention and message events
+        if event_type not in ("app_mention", "message"):
+            return
+
+        channel_type = event.get("channel_type", "")
+
+        # Handle duplicate replies
+        if not reply_to_mentions_only and event_type == "app_mention":
+            return
+
+        # If reply_to_mentions_only is True, ignore every message that is not a DM
+        if reply_to_mentions_only and event_type == "message" and channel_type != "im":
+            return
+
+        # Extract event data
+        user = None
+        message_text = event.get("text", "")
+        channel_id = event.get("channel", "")
+        user = event.get("user")
+        if event.get("thread_ts"):
+            ts = event.get("thread_ts", "")
+        else:
+            ts = event.get("ts", "")
+
+        # Use the timestamp as the session id, so that each thread is a separate session
+        session_id = ts
+
+        if agent:
+            response = await agent.arun(message_text, user_id=user, session_id=session_id)
+        elif team:
+            response = await team.arun(message_text, user_id=user, session_id=session_id)  # type: ignore
+        elif workflow:
+            response = await workflow.arun(message_text, user_id=user, session_id=session_id)  # type: ignore
+
+        if response:
+            if hasattr(response, "reasoning_content") and response.reasoning_content:
+                _send_slack_message(
+                    channel=channel_id,
+                    message=f"Reasoning: \n{response.reasoning_content}",
+                    thread_ts=ts,
+                    italics=True,
+                )
+
+            _send_slack_message(channel=channel_id, message=response.content or "", thread_ts=ts)
 
     def _send_slack_message(channel: str, thread_ts: str, message: str, italics: bool = False):
         if len(message) <= 40000:

agno/os/interfaces/slack/slack.py

@@ -21,12 +21,14 @@ class Slack(BaseInterface):
         workflow: Optional[Workflow] = None,
         prefix: str = "/slack",
         tags: Optional[List[str]] = None,
+        reply_to_mentions_only: bool = True,
     ):
         self.agent = agent
         self.team = team
         self.workflow = workflow
         self.prefix = prefix
         self.tags = tags or ["Slack"]
+        self.reply_to_mentions_only = reply_to_mentions_only
 
         if not (self.agent or self.team or self.workflow):
             raise ValueError("Slack requires an agent, team or workflow")
@@ -34,6 +36,12 @@ class Slack(BaseInterface):
     def get_router(self) -> APIRouter:
         self.router = APIRouter(prefix=self.prefix, tags=self.tags)  # type: ignore
 
-        self.router = attach_routes(router=self.router, agent=self.agent, team=self.team, workflow=self.workflow)
+        self.router = attach_routes(
+            router=self.router,
+            agent=self.agent,
+            team=self.team,
+            workflow=self.workflow,
+            reply_to_mentions_only=self.reply_to_mentions_only,
+        )
 
         return self.router

agno/os/interfaces/whatsapp/router.py

@@ -171,7 +171,6 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
                             f"Could not process image content for user {phone_number}. Type: {type(image_content)}"
                         )
                         await _send_whatsapp_message(phone_number, response.content)  # type: ignore
-                await _send_whatsapp_message(phone_number, response.content)  # type: ignore
             else:
                 await _send_whatsapp_message(phone_number, response.content)  # type: ignore
 

agno/os/interfaces/whatsapp/security.py

@@ -3,6 +3,8 @@ import hmac
 import os
 from typing import Optional
 
+from agno.utils.log import log_warning
+
 
 def is_development_mode() -> bool:
     """Check if the application is running in development mode."""
@@ -36,7 +38,7 @@ def validate_webhook_signature(payload: bytes, signature_header: Optional[str])
     """
     # In development mode, we can bypass signature validation
     if is_development_mode():
-        print("WARNING: Bypassing signature validation in development mode")
+        log_warning("Bypassing signature validation in development mode")
         return True
 
     if not signature_header or not signature_header.startswith("sha256="):

agno/os/mcp.py

@@ -1,7 +1,7 @@
 """Router for MCP interface providing Model Context Protocol endpoints."""
 
 import logging
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, List, Optional, cast
 from uuid import uuid4
 
 from fastmcp import FastMCP
@@ -9,7 +9,7 @@ from fastmcp.server.http import (
     StarletteWithLifespan,
 )
 
-from agno.db.base import SessionType
+from agno.db.base import AsyncBaseDb, SessionType
 from agno.db.schemas import UserMemory
 from agno.os.routers.memory.schemas import (
     UserMemorySchema,
@@ -57,13 +57,14 @@ def get_mcp_server(
             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()],
+            databases=[db.id for db_list in os.dbs.values() for db in db_list],
             chat=os.config.chat if os.config else None,
             session=os._get_session_config(),
             memory=os._get_memory_config(),
             knowledge=os._get_knowledge_config(),
             evals=os._get_evals_config(),
             metrics=os._get_metrics_config(),
+            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 [],
@@ -78,21 +79,21 @@ def get_mcp_server(
         agent = get_agent_by_id(agent_id, os.agents)
         if agent is None:
             raise Exception(f"Agent {agent_id} not found")
-        return agent.run(message)
+        return await agent.arun(message)
 
     @mcp.tool(name="run_team", description="Run a team", tags={"core"})  # type: ignore
     async def run_team(team_id: str, message: str) -> TeamRunOutput:
         team = get_team_by_id(team_id, os.teams)
         if team is None:
             raise Exception(f"Team {team_id} not found")
-        return team.run(message)
+        return await team.arun(message)
 
     @mcp.tool(name="run_workflow", description="Run a workflow", tags={"core"})  # type: ignore
     async def run_workflow(workflow_id: str, message: str) -> WorkflowRunOutput:
         workflow = get_workflow_by_id(workflow_id, os.workflows)
         if workflow is None:
             raise Exception(f"Workflow {workflow_id} not found")
-        return workflow.run(message)
+        return await workflow.arun(message)
 
     # Session Management Tools
     @mcp.tool(name="get_sessions_for_agent", description="Get list of sessions for an agent", tags={"session"})  # type: ignore
@@ -103,15 +104,26 @@ def get_mcp_server(
         sort_by: str = "created_at",
         sort_order: str = "desc",
     ):
-        db = get_db(os.dbs, db_id)
-        sessions, _ = db.get_sessions(
-            session_type=SessionType.AGENT,
-            component_id=agent_id,
-            user_id=user_id,
-            sort_by=sort_by,
-            sort_order=sort_order,
-            deserialize=False,
-        )
+        db = await get_db(os.dbs, db_id)
+        if isinstance(db, AsyncBaseDb):
+            db = cast(AsyncBaseDb, db)
+            sessions = await db.get_sessions(
+                session_type=SessionType.AGENT,
+                component_id=agent_id,
+                user_id=user_id,
+                sort_by=sort_by,
+                sort_order=sort_order,
+                deserialize=False,
+            )
+        else:
+            sessions = db.get_sessions(
+                session_type=SessionType.AGENT,
+                component_id=agent_id,
+                user_id=user_id,
+                sort_by=sort_by,
+                sort_order=sort_order,
+                deserialize=False,
+            )
 
         return {
             "data": [SessionSchema.from_dict(session) for session in sessions],  # type: ignore
@@ -125,15 +137,26 @@ def get_mcp_server(
         sort_by: str = "created_at",
         sort_order: str = "desc",
     ):
-        db = get_db(os.dbs, db_id)
-        sessions, _ = db.get_sessions(
-            session_type=SessionType.TEAM,
-            component_id=team_id,
-            user_id=user_id,
-            sort_by=sort_by,
-            sort_order=sort_order,
-            deserialize=False,
-        )
+        db = await get_db(os.dbs, db_id)
+        if isinstance(db, AsyncBaseDb):
+            db = cast(AsyncBaseDb, db)
+            sessions = await db.get_sessions(
+                session_type=SessionType.TEAM,
+                component_id=team_id,
+                user_id=user_id,
+                sort_by=sort_by,
+                sort_order=sort_order,
+                deserialize=False,
+            )
+        else:
+            sessions = db.get_sessions(
+                session_type=SessionType.TEAM,
+                component_id=team_id,
+                user_id=user_id,
+                sort_by=sort_by,
+                sort_order=sort_order,
+                deserialize=False,
+            )
 
         return {
             "data": [SessionSchema.from_dict(session) for session in sessions],  # type: ignore
@@ -147,15 +170,26 @@ def get_mcp_server(
         sort_by: str = "created_at",
         sort_order: str = "desc",
     ):
-        db = get_db(os.dbs, db_id)
-        sessions, _ = db.get_sessions(
-            session_type=SessionType.WORKFLOW,
-            component_id=workflow_id,
-            user_id=user_id,
-            sort_by=sort_by,
-            sort_order=sort_order,
-            deserialize=False,
-        )
+        db = await get_db(os.dbs, db_id)
+        if isinstance(db, AsyncBaseDb):
+            db = cast(AsyncBaseDb, db)
+            sessions = await db.get_sessions(
+                session_type=SessionType.WORKFLOW,
+                component_id=workflow_id,
+                user_id=user_id,
+                sort_by=sort_by,
+                sort_order=sort_order,
+                deserialize=False,
+            )
+        else:
+            sessions = db.get_sessions(
+                session_type=SessionType.WORKFLOW,
+                component_id=workflow_id,
+                user_id=user_id,
+                sort_by=sort_by,
+                sort_order=sort_order,
+                deserialize=False,
+            )
 
         return {
             "data": [SessionSchema.from_dict(session) for session in sessions],  # type: ignore
@@ -169,7 +203,7 @@ def get_mcp_server(
         user_id: str,
         topics: Optional[List[str]] = None,
     ) -> UserMemorySchema:
-        db = get_db(os.dbs, db_id)
+        db = await get_db(os.dbs, db_id)
         user_memory = db.upsert_user_memory(
             memory=UserMemory(
                 memory_id=str(uuid4()),
@@ -191,13 +225,22 @@ def get_mcp_server(
         sort_order: str = "desc",
         db_id: Optional[str] = None,
     ):
-        db = get_db(os.dbs, db_id)
-        user_memories, _ = db.get_user_memories(
-            user_id=user_id,
-            sort_by=sort_by,
-            sort_order=sort_order,
-            deserialize=False,
-        )
+        db = await get_db(os.dbs, db_id)
+        if isinstance(db, AsyncBaseDb):
+            db = cast(AsyncBaseDb, db)
+            user_memories = await db.get_user_memories(
+                user_id=user_id,
+                sort_by=sort_by,
+                sort_order=sort_order,
+                deserialize=False,
+            )
+        else:
+            user_memories = db.get_user_memories(
+                user_id=user_id,
+                sort_by=sort_by,
+                sort_order=sort_order,
+                deserialize=False,
+            )
         return {
             "data": [UserMemorySchema.from_dict(user_memory) for user_memory in user_memories],  # type: ignore
         }
@@ -209,15 +252,26 @@ def get_mcp_server(
         memory: str,
         user_id: str,
     ) -> UserMemorySchema:
-        db = get_db(os.dbs, db_id)
-        user_memory = db.upsert_user_memory(
-            memory=UserMemory(
-                memory_id=memory_id,
-                memory=memory,
-                user_id=user_id,
-            ),
-            deserialize=False,
-        )
+        db = await get_db(os.dbs, db_id)
+        if isinstance(db, AsyncBaseDb):
+            db = cast(AsyncBaseDb, db)
+            user_memory = await db.upsert_user_memory(
+                memory=UserMemory(
+                    memory_id=memory_id,
+                    memory=memory,
+                    user_id=user_id,
+                ),
+                deserialize=False,
+            )
+        else:
+            user_memory = db.upsert_user_memory(
+                memory=UserMemory(
+                    memory_id=memory_id,
+                    memory=memory,
+                    user_id=user_id,
+                ),
+                deserialize=False,
+            )
         if not user_memory:
             raise Exception("Failed to update memory")
 
@@ -228,8 +282,12 @@ def get_mcp_server(
         db_id: str,
         memory_id: str,
     ) -> None:
-        db = get_db(os.dbs, db_id)
-        db.delete_user_memory(memory_id=memory_id)
+        db = await get_db(os.dbs, db_id)
+        if isinstance(db, AsyncBaseDb):
+            db = cast(AsyncBaseDb, db)
+            await db.delete_user_memory(memory_id=memory_id)
+        else:
+            db.delete_user_memory(memory_id=memory_id)
 
     mcp_app = mcp.http_app(path="/mcp")
     return mcp_app

agno/os/middleware/__init__.py

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