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

agno/app/agui/sync_router.py

@@ -1,120 +0,0 @@
-"""Async router handling exposing an Agno Agent or Team in an AG-UI compatible format."""
-
-import logging
-import uuid
-from typing import Iterator, Optional
-
-from ag_ui.core import (
-    BaseEvent,
-    EventType,
-    RunAgentInput,
-    RunErrorEvent,
-    RunStartedEvent,
-)
-from ag_ui.encoder import EventEncoder
-from fastapi import APIRouter
-from fastapi.responses import StreamingResponse
-
-from agno.agent.agent import Agent
-from agno.app.agui.utils import convert_agui_messages_to_agno_messages, stream_agno_response_as_agui_events
-from agno.team.team import Team
-
-logger = logging.getLogger(__name__)
-
-
-def run_agent(agent: Agent, run_input: RunAgentInput) -> Iterator[BaseEvent]:
-    """Run the contextual Agent, mapping AG-UI input messages to Agno format, and streaming the response in AG-UI format."""
-    run_id = run_input.run_id or str(uuid.uuid4())
-
-    try:
-        # Preparing the input for the Agent and emitting the run started event
-        messages = convert_agui_messages_to_agno_messages(run_input.messages or [])
-        yield RunStartedEvent(type=EventType.RUN_STARTED, thread_id=run_input.thread_id, run_id=run_id)
-
-        # Request streaming response from agent
-        response_stream = agent.run(
-            messages=messages,
-            session_id=run_input.thread_id,
-            stream=True,
-            stream_intermediate_steps=True,
-        )
-
-        # Stream the response content in AG-UI format
-        for event in stream_agno_response_as_agui_events(
-            response_stream=response_stream, thread_id=run_input.thread_id, run_id=run_id
-        ):
-            yield event
-
-    # Emit a RunErrorEvent if any error occurs
-    except Exception as e:
-        logger.error(f"Error running agent: {e}", exc_info=True)
-        yield RunErrorEvent(type=EventType.RUN_ERROR, message=str(e))
-
-
-def run_team(team: Team, input: RunAgentInput) -> Iterator[BaseEvent]:
-    """Run the contextual Team, mapping AG-UI input messages to Agno format, and streaming the response in AG-UI format."""
-    run_id = input.run_id or str(uuid.uuid4())
-    try:
-        # Extract the last user message for team execution
-        messages = convert_agui_messages_to_agno_messages(input.messages or [])
-        yield RunStartedEvent(type=EventType.RUN_STARTED, thread_id=input.thread_id, run_id=run_id)
-
-        # Request streaming response from team
-        response_stream = team.run(
-            message=messages,
-            session_id=input.thread_id,
-            stream=True,
-            stream_intermediate_steps=True,
-        )
-
-        # Stream the response content in AG-UI format
-        for event in stream_agno_response_as_agui_events(
-            response_stream=response_stream, thread_id=input.thread_id, run_id=run_id
-        ):
-            yield event
-
-    except Exception as e:
-        logger.error(f"Error running team: {e}", exc_info=True)
-        yield RunErrorEvent(type=EventType.RUN_ERROR, message=str(e))
-
-
-def get_sync_agui_router(agent: Optional[Agent] = None, team: Optional[Team] = None) -> APIRouter:
-    """Return an AG-UI compatible FastAPI router."""
-    if (agent is None and team is None) or (agent is not None and team is not None):
-        raise ValueError("One of 'agent' or 'team' must be provided.")
-
-    router = APIRouter()
-    encoder = EventEncoder()
-
-    def _run(run_input: RunAgentInput):
-        def event_generator():
-            if agent:
-                for event in run_agent(agent, run_input):
-                    encoded_event = encoder.encode(event)
-                    yield encoded_event
-            elif team:
-                for event in run_team(team, run_input):
-                    encoded_event = encoder.encode(event)
-                    yield encoded_event
-
-        return StreamingResponse(
-            event_generator(),
-            media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive",
-                "Access-Control-Allow-Origin": "*",
-                "Access-Control-Allow-Methods": "POST, GET, OPTIONS",
-                "Access-Control-Allow-Headers": "*",
-            },
-        )
-
-    @router.post("/agui")
-    def run_agent_agui(run_input: RunAgentInput):
-        return _run(run_input)
-
-    @router.get("/status")
-    def get_status():
-        return {"status": "available"}
-
-    return router

agno/app/base.py

@@ -1,186 +0,0 @@
-from abc import ABC, abstractmethod
-from os import getenv
-from typing import Any, Dict, Optional, Union
-from uuid import uuid4
-
-import uvicorn
-from fastapi import FastAPI, HTTPException, Request
-from fastapi.responses import JSONResponse
-from fastapi.routing import APIRouter
-from starlette.middleware.cors import CORSMiddleware
-
-from agno.agent.agent import Agent
-from agno.api.app import AppCreate, create_app
-from agno.app.settings import APIAppSettings
-from agno.team.team import Team
-from agno.utils.log import log_debug, log_info
-
-
-class BaseAPIApp(ABC):
-    type: Optional[str] = None
-
-    def __init__(
-        self,
-        agent: Optional[Agent] = None,
-        team: Optional[Team] = None,
-        settings: Optional[APIAppSettings] = None,
-        api_app: Optional[FastAPI] = None,
-        router: Optional[APIRouter] = None,
-        monitoring: bool = True,
-        app_id: Optional[str] = None,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        version: Optional[str] = None,
-    ):
-        if not agent and not team:
-            raise ValueError("Either agent or team must be provided.")
-
-        if agent and team:
-            raise ValueError("Only one of agent or team can be provided.")
-
-        self.agent: Optional[Agent] = agent
-        self.team: Optional[Team] = team
-        self.settings: APIAppSettings = settings or APIAppSettings()
-        self.api_app: Optional[FastAPI] = api_app
-        self.router: Optional[APIRouter] = router
-        self.monitoring = monitoring
-        self.app_id: Optional[str] = app_id
-        self.name: Optional[str] = name
-        self.description = description
-        self.version = version
-        self.set_app_id()
-
-        if self.agent:
-            if not self.agent.app_id:
-                self.agent.app_id = self.app_id
-            self.agent.initialize_agent()
-
-        if self.team:
-            if not self.team.app_id:
-                self.team.app_id = self.app_id
-            self.team.initialize_team()
-            for member in self.team.members:
-                if isinstance(member, Agent):
-                    if not member.app_id:
-                        member.app_id = self.app_id
-                    member.team_id = None
-                    member.initialize_agent()
-                elif isinstance(member, Team):
-                    member.initialize_team()
-
-    def set_app_id(self) -> str:
-        # If app_id is already set, keep it instead of overriding with UUID
-        if self.app_id is None:
-            self.app_id = str(uuid4())
-
-        # Don't override existing app_id
-        return self.app_id
-
-    def _set_monitoring(self) -> None:
-        monitor_env = getenv("AGNO_MONITOR")
-        if monitor_env is not None:
-            self.monitoring = monitor_env.lower() == "true"
-
-    @abstractmethod
-    def get_router(self) -> APIRouter:
-        raise NotImplementedError("get_router must be implemented")
-
-    @abstractmethod
-    def get_async_router(self) -> APIRouter:
-        raise NotImplementedError("get_async_router must be implemented")
-
-    def get_app(self, use_async: bool = True, prefix: str = "") -> FastAPI:
-        if not self.api_app:
-            kwargs = {
-                "title": self.settings.title,
-            }
-            if self.version:
-                kwargs["version"] = self.version
-            if self.settings.docs_enabled:
-                kwargs["docs_url"] = "/docs"
-                kwargs["redoc_url"] = "/redoc"
-                kwargs["openapi_url"] = "/openapi.json"
-
-            self.api_app = FastAPI(
-                **kwargs,  # type: ignore
-            )
-
-        if not self.api_app:
-            raise Exception("API App could not be created.")
-
-        @self.api_app.exception_handler(HTTPException)
-        async def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
-            return JSONResponse(
-                status_code=exc.status_code,
-                content={"detail": str(exc.detail)},
-            )
-
-        async def general_exception_handler(request: Request, call_next):
-            try:
-                return await call_next(request)
-            except Exception as e:
-                return JSONResponse(
-                    status_code=e.status_code if hasattr(e, "status_code") else 500,
-                    content={"detail": str(e)},
-                )
-
-        self.api_app.middleware("http")(general_exception_handler)
-
-        if not self.router:
-            self.router = APIRouter(prefix=prefix)
-
-        if not self.router:
-            raise Exception("API Router could not be created.")
-
-        if use_async:
-            self.router.include_router(self.get_async_router())
-        else:
-            self.router.include_router(self.get_router())
-
-        self.api_app.include_router(self.router)
-
-        self.api_app.add_middleware(
-            CORSMiddleware,
-            allow_origins=["*"],
-            allow_credentials=True,
-            allow_methods=["*"],
-            allow_headers=["*"],
-            expose_headers=["*"],
-        )
-
-        return self.api_app
-
-    def serve(
-        self,
-        app: Union[str, FastAPI],
-        *,
-        host: str = "localhost",
-        port: int = 7777,
-        reload: bool = False,
-        **kwargs,
-    ):
-        self.set_app_id()
-        self.register_app_on_platform()
-        log_info(f"Starting API on {host}:{port}")
-
-        uvicorn.run(app=app, host=host, port=port, reload=reload, **kwargs)
-
-    def register_app_on_platform(self) -> None:
-        self._set_monitoring()
-        if not self.monitoring:
-            return
-
-        try:
-            log_debug(f"Creating app on Platform: {self.name}, {self.app_id}")
-            create_app(app=AppCreate(name=self.name, app_id=self.app_id, config=self.to_dict()))
-        except Exception as e:
-            log_debug(f"Could not create Agent app: {e}")
-        log_debug(f"Agent app created: {self.name}, {self.app_id}")
-
-    def to_dict(self) -> Dict[str, Any]:
-        payload = {
-            "type": self.type,
-            "description": self.description,
-        }
-        payload = {k: v for k, v in payload.items() if v is not None}
-        return payload

agno/app/discord/__init__.py

@@ -1,3 +0,0 @@
-from agno.app.discord.client import DiscordClient
-
-__all__ = ["DiscordClient"]

agno/app/fastapi/__init__.py

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

agno/app/fastapi/app.py

@@ -1,107 +0,0 @@
-import logging
-from typing import List, Optional, Union
-
-import uvicorn
-from fastapi import FastAPI
-from fastapi.routing import APIRouter
-
-from agno.agent.agent import Agent
-from agno.app.base import BaseAPIApp
-from agno.app.fastapi.async_router import get_async_router
-from agno.app.fastapi.sync_router import get_sync_router
-from agno.app.settings import APIAppSettings
-from agno.app.utils import generate_id
-from agno.team.team import Team
-from agno.utils.log import log_info
-from agno.workflow.workflow import Workflow
-
-logger = logging.getLogger(__name__)
-
-
-class FastAPIApp(BaseAPIApp):
-    type = "fastapi"
-
-    def __init__(
-        self,
-        agents: Optional[List[Agent]] = None,
-        teams: Optional[List[Team]] = None,
-        workflows: Optional[List[Workflow]] = None,
-        settings: Optional[APIAppSettings] = None,
-        api_app: Optional[FastAPI] = None,
-        router: Optional[APIRouter] = None,
-        app_id: Optional[str] = None,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        version: Optional[str] = None,
-        monitoring: bool = True,
-    ):
-        if not agents and not teams and not workflows:
-            raise ValueError("Either agents, teams or workflows must be provided.")
-
-        self.agents: Optional[List[Agent]] = agents
-        self.teams: Optional[List[Team]] = teams
-        self.workflows: Optional[List[Workflow]] = workflows
-
-        self.settings: APIAppSettings = settings or APIAppSettings()
-        self.api_app: Optional[FastAPI] = api_app
-        self.router: Optional[APIRouter] = router
-
-        self.app_id: Optional[str] = app_id
-        self.name: Optional[str] = name
-        self.monitoring = monitoring
-        self.description = description
-        self.version = version
-
-        self.set_app_id()
-
-        if self.agents:
-            for agent in self.agents:
-                if not agent.app_id:
-                    agent.app_id = self.app_id
-                agent.initialize_agent()
-
-        if self.teams:
-            for team in self.teams:
-                if not team.app_id:
-                    team.app_id = self.app_id
-                team.initialize_team()
-                for member in team.members:
-                    if isinstance(member, Agent):
-                        if not member.app_id:
-                            member.app_id = self.app_id
-
-                        member.team_id = None
-                        member.initialize_agent()
-                    elif isinstance(member, Team):
-                        member.initialize_team()
-
-        if self.workflows:
-            for workflow in self.workflows:
-                if hasattr(workflow, "app_id") and not workflow.app_id:
-                    workflow.app_id = self.app_id
-                if not workflow.workflow_id:
-                    workflow.workflow_id = generate_id(workflow.name)
-                workflow.initialize_workflow()
-
-    def get_router(self) -> APIRouter:
-        return get_sync_router(agents=self.agents, teams=self.teams, workflows=self.workflows)
-
-    def get_async_router(self) -> APIRouter:
-        return get_async_router(agents=self.agents, teams=self.teams, workflows=self.workflows)
-
-    def serve(
-        self,
-        app: Union[str, FastAPI],
-        *,
-        host: str = "localhost",
-        port: int = 7777,
-        reload: bool = False,
-        workers: Optional[int] = None,
-        **kwargs,
-    ):
-        self.set_app_id()
-        self.register_app_on_platform()
-
-        log_info(f"Starting API on {host}:{port}")
-
-        uvicorn.run(app=app, host=host, port=port, reload=reload, workers=workers, **kwargs)