agno 2.0.0rc2__py3-none-any.whl → 2.3.0__py3-none-any.whl

agno/os/interfaces/base.py

@@ -1,18 +1,22 @@
 from abc import ABC, abstractmethod
-from typing import Optional
+from typing import List, Optional
 
 from fastapi import APIRouter
 
 from agno.agent import Agent
 from agno.team import Team
+from agno.workflow.workflow import Workflow
 
 
 class BaseInterface(ABC):
     type: str
     version: str = "1.0"
-    router_prefix: str = ""
     agent: Optional[Agent] = None
     team: Optional[Team] = None
+    workflow: Optional[Workflow] = None
+
+    prefix: str
+    tags: List[str]
 
     router: APIRouter
 

agno/os/interfaces/slack/router.py

@@ -1,16 +1,51 @@
-from typing import Optional
+from typing import Optional, Union
 
 from fastapi import APIRouter, BackgroundTasks, HTTPException, Request
+from pydantic import BaseModel, Field
 
 from agno.agent.agent import Agent
 from agno.os.interfaces.slack.security import verify_slack_signature
 from agno.team.team import Team
 from agno.tools.slack import SlackTools
 from agno.utils.log import log_info
+from agno.workflow.workflow import Workflow
 
 
-def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Optional[Team] = None) -> APIRouter:
-    @router.post("/slack/events")
+class SlackEventResponse(BaseModel):
+    """Response model for Slack event processing"""
+
+    status: str = Field(default="ok", description="Processing status")
+
+
+class SlackChallengeResponse(BaseModel):
+    """Response model for Slack URL verification challenge"""
+
+    challenge: str = Field(description="Challenge string to echo back to Slack")
+
+
+def attach_routes(
+    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"
+
+    @router.post(
+        "/events",
+        operation_id=f"slack_events_{entity_type}",
+        name="slack_events",
+        description="Process incoming Slack events",
+        response_model=Union[SlackChallengeResponse, SlackEventResponse],
+        response_model_exclude_none=True,
+        responses={
+            200: {"description": "Event processed successfully"},
+            400: {"description": "Missing Slack headers"},
+            403: {"description": "Invalid Slack signature"},
+        },
+    )
     async def slack_events(request: Request, background_tasks: BackgroundTasks):
         body = await request.body()
         timestamp = request.headers.get("X-Slack-Request-Timestamp")
@@ -26,7 +61,7 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
 
         # Handle URL verification
         if data.get("type") == "url_verification":
-            return {"challenge": data.get("challenge")}
+            return SlackChallengeResponse(challenge=data.get("challenge"))
 
         # Process other event types (e.g., message events) asynchronously
         if "event" in data:
@@ -37,31 +72,54 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
             else:
                 background_tasks.add_task(_process_slack_event, event)
 
-        return {"status": "ok"}
+        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", "")
+        event_type = event.get("type")
 
-            # Use the timestamp as the session id, so that each thread is a separate session
-            session_id = ts
+        # Only handle app_mention and message events
+        if event_type not in ("app_mention", "message"):
+            return
+
+        channel_type = event.get("channel_type", "")
 
-            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
+        # Handle duplicate replies
+        if not reply_to_mentions_only and event_type == "app_mention":
+            return
 
-            if response.reasoning_content:
+        # 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
+                    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):
@@ -85,6 +143,6 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
                 formatted_batch = "\n".join([f"_{line}_" for line in batch_message.split("\n")])
                 SlackTools().send_message_thread(channel=channel, text=formatted_batch or "", thread_ts=thread_ts)
             else:
-                SlackTools().send_message_thread(channel=channel, text=message or "", thread_ts=thread_ts)
+                SlackTools().send_message_thread(channel=channel, text=batch_message or "", thread_ts=thread_ts)
 
     return router

agno/os/interfaces/slack/slack.py

@@ -1,5 +1,4 @@
-import logging
-from typing import Optional
+from typing import List, Optional
 
 from fastapi.routing import APIRouter
 
@@ -7,8 +6,7 @@ from agno.agent.agent import Agent
 from agno.os.interfaces.base import BaseInterface
 from agno.os.interfaces.slack.router import attach_routes
 from agno.team.team import Team
-
-logger = logging.getLogger(__name__)
+from agno.workflow.workflow import Workflow
 
 
 class Slack(BaseInterface):
@@ -16,17 +14,34 @@ class Slack(BaseInterface):
 
     router: APIRouter
 
-    def __init__(self, agent: Optional[Agent] = None, team: Optional[Team] = None):
+    def __init__(
+        self,
+        agent: Optional[Agent] = None,
+        team: Optional[Team] = None,
+        workflow: Optional[Workflow] = None,
+        prefix: str = "/slack",
+        tags: Optional[List[str]] = None,
+        reply_to_mentions_only: bool = True,
+    ):
         self.agent = agent
         self.team = team
-
-        if not self.agent and not self.team:
-            raise ValueError("Slack requires an agent and a team")
-
-    def get_router(self, **kwargs) -> APIRouter:
-        # Cannot be overridden
-        self.router = APIRouter(prefix="/slack", tags=["Slack"])
-
-        self.router = attach_routes(router=self.router, agent=self.agent, team=self.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")
+
+    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,
+            reply_to_mentions_only=self.reply_to_mentions_only,
+        )
 
         return self.router

agno/os/interfaces/whatsapp/router.py

@@ -19,6 +19,9 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
     if agent is None and team is None:
         raise ValueError("Either agent or team must be provided.")
 
+    # Create WhatsApp tools instance once for reuse
+    whatsapp_tools = WhatsAppTools(async_mode=True)
+
     @router.get("/status")
     async def status():
         return {"status": "available"}
@@ -120,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,
@@ -129,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,
@@ -167,6 +172,8 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
                         )
                         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
 
         except Exception as e:
             log_error(f"Error processing message: {str(e)}")
@@ -183,9 +190,9 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
             if italics:
                 # Handle multi-line messages by making each line italic
                 formatted_message = "\n".join([f"_{line}_" for line in message.split("\n")])
-                await WhatsAppTools().send_text_message_async(recipient=recipient, text=formatted_message)
+                await whatsapp_tools.send_text_message_async(recipient=recipient, text=formatted_message)
             else:
-                await WhatsAppTools().send_text_message_async(recipient=recipient, text=message)
+                await whatsapp_tools.send_text_message_async(recipient=recipient, text=message)
             return
 
         # Split message into batches of 4000 characters (WhatsApp message limit is 4096)
@@ -197,8 +204,8 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
             if italics:
                 # Handle multi-line messages by making each line italic
                 formatted_batch = "\n".join([f"_{line}_" for line in batch_message.split("\n")])
-                await WhatsAppTools().send_text_message_async(recipient=recipient, text=formatted_batch)
+                await whatsapp_tools.send_text_message_async(recipient=recipient, text=formatted_batch)
             else:
-                await WhatsAppTools().send_text_message_async(recipient=recipient, text=batch_message)
+                await whatsapp_tools.send_text_message_async(recipient=recipient, text=batch_message)
 
     return router

agno/os/interfaces/whatsapp/whatsapp.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import List, Optional
 
 from fastapi.routing import APIRouter
 
@@ -13,16 +13,23 @@ class Whatsapp(BaseInterface):
 
     router: APIRouter
 
-    def __init__(self, agent: Optional[Agent] = None, team: Optional[Team] = None):
+    def __init__(
+        self,
+        agent: Optional[Agent] = None,
+        team: Optional[Team] = None,
+        prefix: str = "/whatsapp",
+        tags: Optional[List[str]] = None,
+    ):
         self.agent = agent
         self.team = team
+        self.prefix = prefix
+        self.tags = tags or ["Whatsapp"]
 
-        if not self.agent and not self.team:
-            raise ValueError("Whatsapp requires an agent and a team")
+        if not (self.agent or self.team):
+            raise ValueError("Whatsapp requires an agent or a team")
 
-    def get_router(self, **kwargs) -> APIRouter:
-        # Cannot be overridden
-        self.router = APIRouter(prefix="/whatsapp", tags=["Whatsapp"])
+    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)
 

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,
@@ -54,10 +54,10 @@ 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()],
+            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(),
@@ -68,7 +68,7 @@ def get_mcp_server(
             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 [],
             interfaces=[
-                InterfaceResponse(type=interface.type, version=interface.version, route=interface.router_prefix)
+                InterfaceResponse(type=interface.type, version=interface.version, route=interface.prefix)
                 for interface in os.interfaces
             ],
         )
@@ -78,21 +78,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 +103,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 +136,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 +169,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 +202,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 +224,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 +251,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 +281,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

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