agno 1.8.0__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

agno/app/playground/utils.py

@@ -1,46 +0,0 @@
-from typing import Optional
-
-from fastapi import HTTPException, UploadFile
-
-from agno.media import Audio, Image, Video
-from agno.media import File as FileMedia
-from agno.utils.log import logger
-
-
-def process_image(file: UploadFile) -> Image:
-    content = file.file.read()
-    if not content:
-        raise HTTPException(status_code=400, detail="Empty file")
-    return Image(content=content)
-
-
-def process_audio(file: UploadFile) -> Audio:
-    content = file.file.read()
-    if not content:
-        raise HTTPException(status_code=400, detail="Empty file")
-    format = None
-    if file.filename and "." in file.filename:
-        format = file.filename.split(".")[-1].lower()
-    elif file.content_type:
-        format = file.content_type.split("/")[-1]
-
-    return Audio(content=content, format=format)
-
-
-def process_video(file: UploadFile) -> Video:
-    content = file.file.read()
-    if not content:
-        raise HTTPException(status_code=400, detail="Empty file")
-    return Video(content=content, format=file.content_type)
-
-
-def process_document(file: UploadFile) -> Optional[FileMedia]:
-    try:
-        content = file.file.read()
-        if not content:
-            raise HTTPException(status_code=400, detail="Empty file")
-
-        return FileMedia(content=content)
-    except Exception as e:
-        logger.error(f"Error processing document {file.filename}: {e}")
-        return None

agno/app/settings.py

@@ -1,15 +0,0 @@
-from __future__ import annotations
-
-from pydantic_settings import BaseSettings
-
-
-class APIAppSettings(BaseSettings):
-    """App settings for API-based apps that can be set using environment variables.
-
-    Reference: https://pydantic-docs.helpmanual.io/usage/settings/
-    """
-
-    title: str = "agno-app"
-
-    # Set to False to disable docs server at /docs and /redoc
-    docs_enabled: bool = True

agno/app/slack/__init__.py

@@ -1,3 +0,0 @@
-from agno.app.slack.app import SlackAPI
-
-__all__ = ["SlackAPI"]

agno/app/slack/app.py

@@ -1,19 +0,0 @@
-import logging
-
-from fastapi.routing import APIRouter
-
-from agno.app.base import BaseAPIApp
-from agno.app.slack.async_router import get_async_router
-from agno.app.slack.sync_router import get_sync_router
-
-logger = logging.getLogger(__name__)
-
-
-class SlackAPI(BaseAPIApp):
-    type = "slack"
-
-    def get_router(self) -> APIRouter:
-        return get_sync_router(agent=self.agent, team=self.team)
-
-    def get_async_router(self) -> APIRouter:
-        return get_async_router(agent=self.agent, team=self.team)

agno/app/slack/sync_router.py

@@ -1,92 +0,0 @@
-from typing import Optional, cast
-
-from fastapi import APIRouter, BackgroundTasks, HTTPException, Request
-
-from agno.agent.agent import Agent
-from agno.app.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
-
-
-def get_sync_router(agent: Optional[Agent] = None, team: Optional[Team] = None) -> APIRouter:
-    router = APIRouter()
-
-    @router.post("/slack/events")
-    def slack_events(request: Request, background_tasks: BackgroundTasks):
-        body = cast(bytes, 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 = cast(dict, request.json())
-
-        # Handle URL verification
-        if data.get("type") == "url_verification":
-            return {"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 {"status": "ok"}
-
-    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 = agent.run(message_text, user_id=user if user else None, session_id=session_id)
-            elif team:
-                response = team.run(message_text, user_id=user if user else None, session_id=session_id)  # type: ignore
-
-            if 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=message or "", thread_ts=thread_ts)
-
-    return router

agno/app/utils.py

@@ -1,54 +0,0 @@
-from typing import Optional
-from uuid import uuid4
-
-from fastapi import HTTPException, UploadFile
-
-from agno.media import Audio, Image, Video
-from agno.media import File as FileMedia
-from agno.utils.log import logger
-
-
-def process_image(file: UploadFile) -> Image:
-    content = file.file.read()
-    if not content:
-        raise HTTPException(status_code=400, detail="Empty file")
-    return Image(content=content)
-
-
-def process_audio(file: UploadFile) -> Audio:
-    content = file.file.read()
-    if not content:
-        raise HTTPException(status_code=400, detail="Empty file")
-    format = None
-    if file.filename and "." in file.filename:
-        format = file.filename.split(".")[-1].lower()
-    elif file.content_type:
-        format = file.content_type.split("/")[-1]
-
-    return Audio(content=content, format=format)
-
-
-def process_video(file: UploadFile) -> Video:
-    content = file.file.read()
-    if not content:
-        raise HTTPException(status_code=400, detail="Empty file")
-    return Video(content=content, format=file.content_type)
-
-
-def process_document(file: UploadFile) -> Optional[FileMedia]:
-    try:
-        content = file.file.read()
-        if not content:
-            raise HTTPException(status_code=400, detail="Empty file")
-
-        return FileMedia(content=content, mime_type=file.content_type)
-    except Exception as e:
-        logger.error(f"Error processing document {file.filename}: {e}")
-        return None
-
-
-def generate_id(name: Optional[str] = None) -> str:
-    if name:
-        return name.lower().replace(" ", "-").replace("_", "-")
-    else:
-        return str(uuid4())

agno/app/whatsapp/__init__.py

@@ -1,3 +0,0 @@
-from agno.app.whatsapp.app import WhatsappAPI
-
-__all__ = ["WhatsappAPI"]

agno/app/whatsapp/app.py

@@ -1,15 +0,0 @@
-from fastapi.routing import APIRouter
-
-from agno.app.base import BaseAPIApp
-from agno.app.whatsapp.async_router import get_async_router
-from agno.app.whatsapp.sync_router import get_sync_router
-
-
-class WhatsappAPI(BaseAPIApp):
-    type = "whatsapp"
-
-    def get_router(self) -> APIRouter:
-        return get_sync_router(agent=self.agent, team=self.team)
-
-    def get_async_router(self) -> APIRouter:
-        return get_async_router(agent=self.agent, team=self.team)

agno/app/whatsapp/sync_router.py

@@ -1,197 +0,0 @@
-import base64
-from os import getenv
-from typing import Optional, cast
-
-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_debug, log_error, log_info, log_warning
-from agno.utils.whatsapp import get_media, send_image_message, typing_indicator, upload_media
-
-from .security import validate_webhook_signature
-
-
-def get_sync_router(agent: Optional[Agent] = None, team: Optional[Team] = None) -> APIRouter:
-    router = APIRouter()
-
-    if agent is None and team is None:
-        raise ValueError("Either agent or team must be provided.")
-
-    @router.get("/status")
-    def status():
-        return {"status": "available"}
-
-    @router.get("/webhook")
-    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")
-    def webhook(request: Request, background_tasks: BackgroundTasks):
-        """Handle incoming WhatsApp messages"""
-        try:
-            # Get raw payload for signature validation
-            payload = cast(bytes, 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 = cast(dict, 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))
-
-    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")
-            typing_indicator(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.get("from", "")
-            log_debug(f"Processing message from {phone_number}: {message_text}")
-
-            # Generate and send response
-            if agent:
-                response = agent.run(
-                    message_text,
-                    user_id=phone_number,
-                    images=[Image(content=get_media(message_image))] if message_image else None,
-                    files=[File(content=get_media(message_doc))] if message_doc else None,
-                    videos=[Video(content=get_media(message_video))] if message_video else None,
-                    audio=[Audio(content=get_media(message_audio))] if message_audio else None,
-                )
-            elif team:
-                response = team.run(  # type: ignore
-                    message_text,
-                    user_id=phone_number,
-                    files=[File(content=get_media(message_doc))] if message_doc else None,
-                    images=[Image(content=get_media(message_image))] if message_image else None,
-                    videos=[Video(content=get_media(message_video))] if message_video else None,
-                    audio=[Audio(content=get_media(message_audio))] if message_audio else None,
-                )
-
-            if response.reasoning_content:
-                _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[0].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 = upload_media(media_data=image_bytes, mime_type="image/png", filename="image.png")
-                        send_image_message(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)}"
-                        )
-                        _send_whatsapp_message(phone_number, response.content or "")
-            else:
-                _send_whatsapp_message(phone_number, response.content or "")
-
-        except Exception as e:
-            log_error(f"Error processing message: {str(e)}")
-            # Optionally send an error message to the user
-            try:
-                _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)}")
-
-    def _send_whatsapp_message(recipient: str, message: str, italics: bool = False):
-        if len(message) <= 4096:
-            WhatsAppTools().send_text_message_sync(recipient=recipient, text=f"_{message}_" if italics else 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}"
-            WhatsAppTools().send_text_message_sync(
-                recipient=recipient, text=f"_{batch_message}_" if italics else batch_message
-            )
-
-    return router