agno 1.8.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

agno/api/user.py

@@ -1,160 +0,0 @@
-from typing import Dict, List, Optional, Union
-
-from httpx import Response, codes
-
-from agno.api.api import api, invalid_response
-from agno.api.routes import ApiRoutes
-from agno.api.schemas.user import EmailPasswordAuthSchema, UserSchema
-from agno.cli.config import AgnoCliConfig
-from agno.cli.settings import agno_cli_settings
-from agno.utils.log import logger
-
-
-def user_ping() -> bool:
-    if not agno_cli_settings.api_enabled:
-        return False
-
-    logger.debug("--**-- Ping user api")
-    with api.Client() as api_client:
-        try:
-            r: Response = api_client.get(ApiRoutes.USER_HEALTH)
-            if invalid_response(r):
-                return False
-
-            if r.status_code == codes.OK:
-                return True
-        except Exception as e:
-            logger.debug(f"Could not ping user api: {e}")
-    return False
-
-
-def authenticate_and_get_user(auth_token: str, existing_user: Optional[UserSchema] = None) -> Optional[UserSchema]:
-    if not agno_cli_settings.api_enabled:
-        return None
-
-    from agno.cli.credentials import read_auth_token
-
-    logger.debug("--**-- Getting user")
-    auth_header = {agno_cli_settings.auth_token_header: auth_token}
-    anon_user = None
-    if existing_user is not None:
-        if existing_user.email == "anon":
-            logger.debug(f"Claiming anonymous user: {existing_user.id_user}")
-            anon_user = {
-                "email": existing_user.email,
-                "id_user": existing_user.id_user,
-                "auth_token": read_auth_token() or "",
-            }
-    with api.Client() as api_client:
-        try:
-            r: Response = api_client.post(ApiRoutes.USER_CLI_AUTH, headers=auth_header, json=anon_user)
-            if invalid_response(r):
-                return None
-
-            user_data = r.json()
-            if not isinstance(user_data, dict):
-                return None
-
-            return UserSchema.model_validate(user_data)
-
-        except Exception as e:
-            logger.debug(f"Could not authenticate user: {e}")
-    return None
-
-
-def sign_in_user(sign_in_data: EmailPasswordAuthSchema) -> Optional[UserSchema]:
-    if not agno_cli_settings.api_enabled:
-        return None
-
-    from agno.cli.credentials import save_auth_token
-
-    logger.debug("--**-- Signing in user")
-    with api.Client() as api_client:
-        try:
-            r: Response = api_client.post(ApiRoutes.USER_SIGN_IN, json=sign_in_data.model_dump())
-            if invalid_response(r):
-                return None
-
-            agno_auth_token = r.headers.get(agno_cli_settings.auth_token_header)
-            if agno_auth_token is None:
-                logger.error("Could not authenticate user")
-                return None
-
-            user_data = r.json()
-            if not isinstance(user_data, dict):
-                return None
-
-            current_user: UserSchema = UserSchema.model_validate(user_data)
-
-            if current_user is not None:
-                save_auth_token(agno_auth_token)
-                return current_user
-        except Exception as e:
-            logger.debug(f"Could not sign in user: {e}")
-    return None
-
-
-def user_is_authenticated() -> bool:
-    if not agno_cli_settings.api_enabled:
-        return False
-
-    logger.debug("--**-- Checking if user is authenticated")
-    agno_config: Optional[AgnoCliConfig] = AgnoCliConfig.from_saved_config()
-    if agno_config is None:
-        return False
-    user: Optional[UserSchema] = agno_config.user
-    if user is None:
-        return False
-
-    with api.AuthenticatedClient() as api_client:
-        try:
-            r: Response = api_client.post(
-                ApiRoutes.USER_AUTHENTICATE, json=user.model_dump(include={"id_user", "email"})
-            )
-            if invalid_response(r):
-                return False
-
-            response_json: Union[Dict, List] = r.json()
-            if response_json is None or not isinstance(response_json, dict):
-                logger.error("Could not parse response")
-                return False
-            if response_json.get("status") == "success":
-                return True
-        except Exception as e:
-            logger.debug(f"Could not check if user is authenticated: {e}")
-    return False
-
-
-def create_anon_user() -> Optional[UserSchema]:
-    if not agno_cli_settings.api_enabled:
-        return None
-
-    from agno.cli.credentials import save_auth_token
-
-    logger.debug("--**-- Creating anon user")
-    with api.Client() as api_client:
-        try:
-            r: Response = api_client.post(
-                ApiRoutes.USER_CREATE_ANON,
-                json={"user": {"email": "anon", "username": "anon", "is_machine": True}},
-                timeout=2.0,
-            )
-            if invalid_response(r):
-                return None
-
-            agno_auth_token = r.headers.get(agno_cli_settings.auth_token_header)
-            if agno_auth_token is None:
-                logger.debug("Could not create anon user")
-                return None
-
-            user_data = r.json()
-            if not isinstance(user_data, dict):
-                return None
-
-            current_user: UserSchema = UserSchema.model_validate(user_data)
-            if current_user is not None:
-                save_auth_token(agno_auth_token)
-                return current_user
-        except Exception as e:
-            logger.debug(f"Could not create anon user: {e}")
-    return None

agno/api/workflows.py

@@ -1,33 +0,0 @@
-from agno.api.api import api
-from agno.api.routes import ApiRoutes
-from agno.api.schemas.workflows import WorkflowCreate
-from agno.cli.settings import agno_cli_settings
-from agno.utils.log import log_debug
-
-
-def create_workflow(workflow: WorkflowCreate) -> None:
-    if not agno_cli_settings.api_enabled:
-        return
-
-    with api.AuthenticatedClient() as api_client:
-        try:
-            api_client.post(
-                ApiRoutes.WORKFLOW_CREATE,
-                json=workflow.model_dump(exclude_none=True),
-            )
-        except Exception as e:
-            log_debug(f"Could not create Workflow: {e}")
-
-
-async def acreate_workflow(workflow: WorkflowCreate) -> None:
-    if not agno_cli_settings.api_enabled:
-        return
-
-    async with api.AuthenticatedAsyncClient() as api_client:
-        try:
-            await api_client.post(
-                ApiRoutes.WORKFLOW_CREATE,
-                json=workflow.model_dump(exclude_none=True),
-            )
-        except Exception as e:
-            log_debug(f"Could not create Team: {e}")

agno/api/workspace.py

@@ -1,175 +0,0 @@
-from typing import Dict, List, Optional, Union
-
-from httpx import Response
-
-from agno.api.api import api, invalid_response
-from agno.api.routes import ApiRoutes
-from agno.api.schemas.user import TeamIdentifier, TeamSchema, UserSchema
-from agno.api.schemas.workspace import (
-    WorkspaceCreate,
-    WorkspaceEvent,
-    WorkspaceSchema,
-    WorkspaceUpdate,
-)
-from agno.cli.settings import agno_cli_settings
-from agno.utils.log import logger
-
-
-def get_teams_for_user(user: UserSchema) -> Optional[List[TeamSchema]]:
-    logger.debug("--**-- Reading teams for user")
-    with api.AuthenticatedClient() as api_client:
-        try:
-            r: Response = api_client.post(
-                ApiRoutes.TEAM_READ_ALL,
-                json={
-                    "user": user.model_dump(include={"id_user", "email"}),
-                },
-                timeout=2.0,
-            )
-            if invalid_response(r):
-                return None
-
-            response_json: Optional[List[Dict]] = r.json()
-            if response_json is None:
-                return None
-
-            teams: List[TeamSchema] = [TeamSchema.model_validate(team) for team in response_json]
-            return teams
-        except Exception as e:
-            logger.debug(f"Could not read teams: {e}")
-    return None
-
-
-def create_workspace_for_user(
-    user: UserSchema, workspace: WorkspaceCreate, team: Optional[TeamIdentifier] = None
-) -> Optional[WorkspaceSchema]:
-    logger.debug("--**-- Creating workspace")
-    with api.AuthenticatedClient() as api_client:
-        try:
-            payload = {
-                "user": user.model_dump(include={"id_user", "email"}),
-                "workspace": workspace.model_dump(exclude_none=True),
-            }
-            if team is not None:
-                payload["team"] = team.model_dump(exclude_none=True)
-
-            r: Response = api_client.post(
-                ApiRoutes.WORKSPACE_CREATE,
-                json=payload,
-                timeout=2.0,
-            )
-            if invalid_response(r):
-                try:
-                    error_msg = r.json().get("detail", "Permission denied")
-                except Exception:
-                    error_msg = f"Could not create workspace: {r.text}"
-                logger.error(error_msg)
-                return None
-
-            response_json: Union[Dict, List] = r.json()
-            if response_json is None:
-                return None
-
-            created_workspace: WorkspaceSchema = WorkspaceSchema.model_validate(response_json)
-            if created_workspace is not None:
-                return created_workspace
-        except Exception as e:
-            logger.debug(f"Could not create workspace: {e}")
-    return None
-
-
-def update_workspace_for_user(user: UserSchema, workspace: WorkspaceUpdate) -> Optional[WorkspaceSchema]:
-    logger.debug("--**-- Updating workspace for user")
-    with api.AuthenticatedClient() as api_client:
-        try:
-            payload = {
-                "user": user.model_dump(include={"id_user", "email"}),
-                "workspace": workspace.model_dump(exclude_none=True),
-            }
-
-            r: Response = api_client.post(
-                ApiRoutes.WORKSPACE_UPDATE,
-                json=payload,
-            )
-            if invalid_response(r):
-                try:
-                    error_msg = r.json().get("detail", "Could not update workspace")
-                except Exception:
-                    error_msg = f"Could not update workspace: {r.text}"
-                logger.error(error_msg)
-                return None
-
-            response_json: Union[Dict, List] = r.json()
-            if response_json is None:
-                return None
-
-            updated_workspace: WorkspaceSchema = WorkspaceSchema.model_validate(response_json)
-            if updated_workspace is not None:
-                return updated_workspace
-        except Exception as e:
-            logger.debug(f"Could not update workspace: {e}")
-    return None
-
-
-def update_workspace_for_team(
-    user: UserSchema, workspace: WorkspaceUpdate, team: TeamIdentifier
-) -> Optional[WorkspaceSchema]:
-    logger.debug("--**-- Updating workspace for team")
-    with api.AuthenticatedClient() as api_client:
-        try:
-            payload = {
-                "user": user.model_dump(include={"id_user", "email"}),
-                "team_workspace": workspace.model_dump(exclude_none=True).update({"id_team": team.id_team}),
-            }
-
-            r: Response = api_client.post(
-                ApiRoutes.WORKSPACE_UPDATE,
-                json=payload,
-            )
-            if invalid_response(r):
-                try:
-                    error_msg = r.json().get("detail", "Could not update workspace")
-                except Exception:
-                    error_msg = f"Could not update workspace: {r.text}"
-                logger.error(error_msg)
-                return None
-
-            response_json: Union[Dict, List] = r.json()
-            if response_json is None:
-                return None
-
-            updated_workspace: WorkspaceSchema = WorkspaceSchema.model_validate(response_json)
-            if updated_workspace is not None:
-                return updated_workspace
-        except Exception as e:
-            logger.debug(f"Could not update workspace: {e}")
-    return None
-
-
-def log_workspace_event(user: UserSchema, workspace_event: WorkspaceEvent) -> bool:
-    if not agno_cli_settings.api_enabled:
-        return False
-
-    logger.debug("--**-- Log workspace event")
-    with api.AuthenticatedClient() as api_client:
-        try:
-            r: Response = api_client.post(
-                ApiRoutes.WORKSPACE_EVENT_CREATE,
-                json={
-                    "user": user.model_dump(include={"id_user", "email"}),
-                    "event": workspace_event.model_dump(exclude_none=True),
-                },
-            )
-            if invalid_response(r):
-                return False
-
-            response_json: Union[Dict, List] = r.json()
-            if response_json is None:
-                return False
-
-            if isinstance(response_json, dict) and response_json.get("status") == "success":
-                return True
-            return False
-        except Exception as e:
-            logger.debug(f"Could not log workspace event: {e}")
-    return False

agno/app/agui/__init__.py

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

agno/app/agui/app.py

@@ -1,17 +0,0 @@
-"""Main class for the AG-UI app, used to expose an Agno Agent or Team in an AG-UI compatible format."""
-
-from fastapi.routing import APIRouter
-
-from agno.app.agui.async_router import get_async_agui_router
-from agno.app.agui.sync_router import get_sync_agui_router
-from agno.app.base import BaseAPIApp
-
-
-class AGUIApp(BaseAPIApp):
-    type = "agui"
-
-    def get_router(self) -> APIRouter:
-        return get_sync_agui_router(agent=self.agent, team=self.team)
-
-    def get_async_router(self) -> APIRouter:
-        return get_async_agui_router(agent=self.agent, team=self.team)

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