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

agno/os/interfaces/slack/router.py

@@ -0,0 +1,148 @@
+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
+
+
+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")
+        slack_signature = request.headers.get("X-Slack-Signature", "")
+
+        if not timestamp or not slack_signature:
+            raise HTTPException(status_code=400, detail="Missing Slack headers")
+
+        if not verify_slack_signature(body, timestamp, slack_signature):
+            raise HTTPException(status_code=403, detail="Invalid signature")
+
+        data = await request.json()
+
+        # Handle URL verification
+        if data.get("type") == "url_verification":
+            return SlackChallengeResponse(challenge=data.get("challenge"))
+
+        # Process other event types (e.g., message events) asynchronously
+        if "event" in data:
+            event = data["event"]
+            if event.get("bot_id"):
+                log_info("bot event")
+                pass
+            else:
+                background_tasks.add_task(_process_slack_event, event)
+
+        return SlackEventResponse(status="ok")
+
+    async def _process_slack_event(event: dict):
+        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:
+            if italics:
+                # Handle multi-line messages by making each line italic
+                formatted_message = "\n".join([f"_{line}_" for line in message.split("\n")])
+                SlackTools().send_message_thread(channel=channel, text=formatted_message or "", thread_ts=thread_ts)
+            else:
+                SlackTools().send_message_thread(channel=channel, text=message or "", thread_ts=thread_ts)
+            return
+
+        # Split message into batches of 4000 characters (WhatsApp message limit is 4096)
+        message_batches = [message[i : i + 40000] for i in range(0, len(message), 40000)]
+
+        # Add a prefix with the batch number
+        for i, batch in enumerate(message_batches, 1):
+            batch_message = f"[{i}/{len(message_batches)}] {batch}"
+            if italics:
+                # Handle multi-line messages by making each line italic
+                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=batch_message or "", thread_ts=thread_ts)
+
+    return router

agno/os/interfaces/slack/security.py

@@ -0,0 +1,30 @@
+import hashlib
+import hmac
+import time
+from os import getenv
+
+from fastapi import HTTPException
+
+from agno.utils.log import log_error
+
+try:
+    SLACK_SIGNING_SECRET = getenv("SLACK_SIGNING_SECRET")
+except Exception as e:
+    log_error(f"Slack signin secret missing: {e}")
+
+
+def verify_slack_signature(body: bytes, timestamp: str, slack_signature: str) -> bool:
+    if not SLACK_SIGNING_SECRET:
+        raise HTTPException(status_code=500, detail="SLACK_SIGNING_SECRET is not set")
+
+    # Ensure the request timestamp is recent (e.g., to prevent replay attacks)
+    if abs(time.time() - int(timestamp)) > 60 * 5:
+        return False
+
+    sig_basestring = f"v0:{timestamp}:{body.decode('utf-8')}"
+    my_signature = (
+        "v0="
+        + hmac.new(SLACK_SIGNING_SECRET.encode("utf-8"), sig_basestring.encode("utf-8"), hashlib.sha256).hexdigest()
+    )
+
+    return hmac.compare_digest(my_signature, slack_signature)

agno/os/interfaces/slack/slack.py

@@ -0,0 +1,47 @@
+from typing import List, Optional
+
+from fastapi.routing import APIRouter
+
+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
+from agno.workflow.workflow import Workflow
+
+
+class Slack(BaseInterface):
+    type = "slack"
+
+    router: APIRouter
+
+    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
+        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/__init__.py

@@ -0,0 +1,3 @@
+from agno.os.interfaces.whatsapp.whatsapp import Whatsapp
+
+__all__ = ["Whatsapp"]

agno/os/interfaces/whatsapp/router.py

@@ -0,0 +1,210 @@
+import base64
+from os import getenv
+from typing import Optional
+
+from fastapi import APIRouter, BackgroundTasks, HTTPException, Request
+from fastapi.responses import PlainTextResponse
+
+from agno.agent.agent import Agent
+from agno.media import Audio, File, Image, Video
+from agno.team.team import Team
+from agno.tools.whatsapp import WhatsAppTools
+from agno.utils.log import log_error, log_info, log_warning
+from agno.utils.whatsapp import get_media_async, send_image_message_async, typing_indicator_async, upload_media_async
+
+from .security import validate_webhook_signature
+
+
+def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Optional[Team] = None) -> APIRouter:
+    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"}
+
+    @router.get("/webhook")
+    async def verify_webhook(request: Request):
+        """Handle WhatsApp webhook verification"""
+        mode = request.query_params.get("hub.mode")
+        token = request.query_params.get("hub.verify_token")
+        challenge = request.query_params.get("hub.challenge")
+
+        verify_token = getenv("WHATSAPP_VERIFY_TOKEN")
+        if not verify_token:
+            raise HTTPException(status_code=500, detail="WHATSAPP_VERIFY_TOKEN is not set")
+
+        if mode == "subscribe" and token == verify_token:
+            if not challenge:
+                raise HTTPException(status_code=400, detail="No challenge received")
+            return PlainTextResponse(content=challenge)
+
+        raise HTTPException(status_code=403, detail="Invalid verify token or mode")
+
+    @router.post("/webhook")
+    async def webhook(request: Request, background_tasks: BackgroundTasks):
+        """Handle incoming WhatsApp messages"""
+        try:
+            # Get raw payload for signature validation
+            payload = await request.body()
+            signature = request.headers.get("X-Hub-Signature-256")
+
+            # Validate webhook signature
+            if not validate_webhook_signature(payload, signature):
+                log_warning("Invalid webhook signature")
+                raise HTTPException(status_code=403, detail="Invalid signature")
+
+            body = await request.json()
+
+            # Validate webhook data
+            if body.get("object") != "whatsapp_business_account":
+                log_warning(f"Received non-WhatsApp webhook object: {body.get('object')}")
+                return {"status": "ignored"}
+
+            # Process messages in background
+            for entry in body.get("entry", []):
+                for change in entry.get("changes", []):
+                    messages = change.get("value", {}).get("messages", [])
+
+                    if not messages:
+                        continue
+
+                    message = messages[0]
+                    background_tasks.add_task(process_message, message, agent, team)
+
+            return {"status": "processing"}
+
+        except Exception as e:
+            log_error(f"Error processing webhook: {str(e)}")
+            raise HTTPException(status_code=500, detail=str(e))
+
+    async def process_message(message: dict, agent: Optional[Agent], team: Optional[Team]):
+        """Process a single WhatsApp message in the background"""
+        try:
+            message_image = None
+            message_video = None
+            message_audio = None
+            message_doc = None
+
+            message_id = message.get("id")
+            await typing_indicator_async(message_id)
+
+            if message.get("type") == "text":
+                message_text = message["text"]["body"]
+            elif message.get("type") == "image":
+                try:
+                    message_text = message["image"]["caption"]
+                except Exception:
+                    message_text = "Describe the image"
+                message_image = message["image"]["id"]
+            elif message.get("type") == "video":
+                try:
+                    message_text = message["video"]["caption"]
+                except Exception:
+                    message_text = "Describe the video"
+                message_video = message["video"]["id"]
+            elif message.get("type") == "audio":
+                message_text = "Reply to audio"
+                message_audio = message["audio"]["id"]
+            elif message.get("type") == "document":
+                message_text = "Process the document"
+                message_doc = message["document"]["id"]
+            else:
+                return
+
+            phone_number = message["from"]
+            log_info(f"Processing message from {phone_number}: {message_text}")
+
+            # Generate and send response
+            if agent:
+                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,
+                    audio=[Audio(content=await get_media_async(message_audio))] if message_audio else None,
+                )
+            elif team:
+                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,
+                    audio=[Audio(content=await get_media_async(message_audio))] if message_audio else None,
+                )
+
+            if response.reasoning_content:
+                await _send_whatsapp_message(phone_number, f"Reasoning: \n{response.reasoning_content}", italics=True)
+
+            if response.images:
+                number_of_images = len(response.images)
+                log_info(f"images generated: f{number_of_images}")
+                for i in range(number_of_images):
+                    image_content = response.images[i].content
+                    image_bytes = None
+                    if isinstance(image_content, bytes):
+                        try:
+                            decoded_string = image_content.decode("utf-8")
+
+                            image_bytes = base64.b64decode(decoded_string)
+                        except UnicodeDecodeError:
+                            image_bytes = image_content
+                    elif isinstance(image_content, str):
+                        image_bytes = base64.b64decode(image_content)
+                    else:
+                        log_error(f"Unexpected image content type: {type(image_content)} for user {phone_number}")
+
+                    if image_bytes:
+                        media_id = await upload_media_async(
+                            media_data=image_bytes, mime_type="image/png", filename="image.png"
+                        )
+                        await send_image_message_async(media_id=media_id, recipient=phone_number, text=response.content)
+                    else:
+                        log_warning(
+                            f"Could not process image content for user {phone_number}. Type: {type(image_content)}"
+                        )
+                        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)}")
+
+            try:
+                await _send_whatsapp_message(
+                    phone_number, "Sorry, there was an error processing your message. Please try again later."
+                )
+            except Exception as send_error:
+                log_error(f"Error sending error message: {str(send_error)}")
+
+    async def _send_whatsapp_message(recipient: str, message: str, italics: bool = False):
+        if len(message) <= 4096:
+            if italics:
+                # Handle multi-line messages by making each line italic
+                formatted_message = "\n".join([f"_{line}_" for line in message.split("\n")])
+                await whatsapp_tools.send_text_message_async(recipient=recipient, text=formatted_message)
+            else:
+                await whatsapp_tools.send_text_message_async(recipient=recipient, text=message)
+            return
+
+        # Split message into batches of 4000 characters (WhatsApp message limit is 4096)
+        message_batches = [message[i : i + 4000] for i in range(0, len(message), 4000)]
+
+        # Add a prefix with the batch number
+        for i, batch in enumerate(message_batches, 1):
+            batch_message = f"[{i}/{len(message_batches)}] {batch}"
+            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 whatsapp_tools.send_text_message_async(recipient=recipient, text=formatted_batch)
+            else:
+                await whatsapp_tools.send_text_message_async(recipient=recipient, text=batch_message)
+
+    return router

agno/os/interfaces/whatsapp/security.py

@@ -0,0 +1,55 @@
+import hashlib
+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."""
+    return os.getenv("APP_ENV", "development").lower() == "development"
+
+
+def get_app_secret() -> str:
+    """
+    Get the WhatsApp app secret from environment variables.
+    In development mode, returns a dummy secret if WHATSAPP_APP_SECRET is not set.
+    """
+    app_secret = os.getenv("WHATSAPP_APP_SECRET")
+
+    if not app_secret:
+        raise ValueError("WHATSAPP_APP_SECRET environment variable is not set in production mode")
+
+    return app_secret
+
+
+def validate_webhook_signature(payload: bytes, signature_header: Optional[str]) -> bool:
+    """
+    Validate the webhook payload using SHA256 signature.
+    In development mode, signature validation can be bypassed.
+
+    Args:
+        payload: The raw request payload bytes
+        signature_header: The X-Hub-Signature-256 header value
+
+    Returns:
+        bool: True if signature is valid or in development mode, False otherwise
+    """
+    # In development mode, we can bypass signature validation
+    if is_development_mode():
+        log_warning("Bypassing signature validation in development mode")
+        return True
+
+    if not signature_header or not signature_header.startswith("sha256="):
+        return False
+
+    app_secret = get_app_secret()
+    expected_signature = signature_header.split("sha256=")[1]
+
+    # Calculate signature
+    hmac_obj = hmac.new(app_secret.encode("utf-8"), payload, hashlib.sha256)
+    calculated_signature = hmac_obj.hexdigest()
+
+    # Compare signatures using constant-time comparison
+    return hmac.compare_digest(calculated_signature, expected_signature)

agno/os/interfaces/whatsapp/whatsapp.py

@@ -0,0 +1,36 @@
+from typing import List, Optional
+
+from fastapi.routing import APIRouter
+
+from agno.agent import Agent
+from agno.os.interfaces.base import BaseInterface
+from agno.os.interfaces.whatsapp.router import attach_routes
+from agno.team import Team
+
+
+class Whatsapp(BaseInterface):
+    type = "whatsapp"
+
+    router: APIRouter
+
+    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 or self.team):
+            raise ValueError("Whatsapp requires an agent or a team")
+
+    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)
+
+        return self.router