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

agno/api/app.py

@@ -1,35 +0,0 @@
-from agno.api.api import api
-from agno.api.routes import ApiRoutes
-from agno.api.schemas.app import AppCreate
-from agno.cli.settings import agno_cli_settings
-from agno.utils.log import log_debug
-
-
-def create_app(app: AppCreate) -> None:
-    if not agno_cli_settings.api_enabled:
-        return
-
-    with api.AuthenticatedClient() as api_client:
-        try:
-            api_client.post(
-                ApiRoutes.APP_CREATE,
-                json=app.model_dump(exclude_none=True),
-            )
-
-        except Exception as e:
-            log_debug(f"Could not create App: {e}")
-
-
-async def acreate_app(app: AppCreate) -> None:
-    if not agno_cli_settings.api_enabled:
-        return
-
-    async with api.AuthenticatedAsyncClient() as api_client:
-        try:
-            await api_client.post(
-                ApiRoutes.APP_CREATE,
-                json=app.model_dump(exclude_none=True),
-            )
-
-        except Exception as e:
-            log_debug(f"Could not create App: {e}")

agno/api/playground.py

@@ -1,92 +0,0 @@
-from os import getenv
-from pathlib import Path
-from typing import Dict, List, Union
-
-from httpx import Client as HttpxClient
-from httpx import Response
-
-from agno.api.api import api, invalid_response
-from agno.api.routes import ApiRoutes
-from agno.api.schemas.playground import PlaygroundEndpointCreate
-from agno.cli.credentials import read_auth_token
-from agno.cli.settings import agno_cli_settings
-from agno.constants import AGNO_API_KEY_ENV_VAR
-from agno.utils.log import logger
-
-
-def create_playground_endpoint(playground: PlaygroundEndpointCreate) -> bool:
-    logger.debug("--**-- Creating Playground Endpoint")
-    with api.AuthenticatedClient() as api_client:
-        try:
-            r: Response = api_client.post(
-                ApiRoutes.PLAYGROUND_ENDPOINT_CREATE,
-                json={"playground": playground.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
-
-            # logger.debug(f"Response: {response_json}")
-            return True
-        except Exception as e:
-            logger.debug(f"Could not create Playground Endpoint: {e}")
-    return False
-
-
-def deploy_playground_archive(name: str, tar_path: Path) -> bool:
-    """Deploy a playground archive.
-
-    Args:
-        name (str): Name of the archive
-        tar_path (Path): Path to the tar file
-
-    Returns:
-        bool: True if deployment was successful
-
-    Raises:
-        ValueError: If tar_path is invalid or file is too large
-        RuntimeError: If deployment fails
-    """
-    logger.debug("--**-- Deploying Playground App")
-
-    # Validate input
-    if not tar_path.exists():
-        raise ValueError(f"Tar file not found: {tar_path}")
-
-    # Check file size (e.g., 100MB limit)
-    max_size = 100 * 1024 * 1024  # 100MB
-    if tar_path.stat().st_size > max_size:
-        raise ValueError(f"Tar file too large: {tar_path.stat().st_size} bytes (max {max_size} bytes)")
-
-    # Build headers
-    headers = {}
-    token = read_auth_token()
-    if token := read_auth_token():
-        headers[agno_cli_settings.auth_token_header] = token
-    if agno_api_key := getenv(AGNO_API_KEY_ENV_VAR):
-        headers["Authorization"] = f"Bearer {agno_api_key}"
-
-    try:
-        with (
-            HttpxClient(base_url=agno_cli_settings.api_url, headers=headers) as api_client,
-            open(tar_path, "rb") as file,
-        ):
-            files = {"file": (tar_path.name, file, "application/gzip")}
-            r: Response = api_client.post(
-                ApiRoutes.PLAYGROUND_APP_DEPLOY,
-                files=files,
-                data={"name": name},
-            )
-
-            if invalid_response(r):
-                raise RuntimeError(f"Deployment failed with status {r.status_code}: {r.text}")
-
-            response_json: Dict = r.json()
-            logger.debug(f"Response: {response_json}")
-            return True
-
-    except Exception as e:
-        raise RuntimeError(f"Failed to deploy playground app: {str(e)}") from e

agno/api/schemas/app.py

@@ -1,12 +0,0 @@
-from typing import Any, Dict, Optional
-
-from pydantic import BaseModel
-
-
-class AppCreate(BaseModel):
-    """Data sent to API to create an App"""
-
-    app_id: Optional[str] = None
-    name: Optional[str] = None
-    description: Optional[str] = None
-    config: Dict[str, Any]

agno/api/schemas/playground.py

@@ -1,22 +0,0 @@
-from typing import Any, Dict, Optional
-from uuid import UUID
-
-from pydantic import BaseModel, ConfigDict
-
-
-class PlaygroundEndpointCreate(BaseModel):
-    """Data sent to API to create a playground endpoint"""
-
-    endpoint: str
-    playground_data: Optional[Dict[str, Any]] = None
-
-
-class PlaygroundEndpointSchema(BaseModel):
-    """Schema for a playground endpoint returned by API"""
-
-    id_workspace: Optional[UUID] = None
-    id_playground_endpoint: Optional[UUID] = None
-    endpoint: str
-    playground_data: Optional[Dict[str, Any]] = None
-
-    model_config = ConfigDict(from_attributes=True)

agno/api/schemas/user.py

@@ -1,35 +0,0 @@
-from typing import Any, Dict, Optional
-
-from pydantic import BaseModel
-
-
-class UserSchema(BaseModel):
-    """Schema for user data returned by the API."""
-
-    id_user: str
-    email: Optional[str] = None
-    username: Optional[str] = None
-    name: Optional[str] = None
-    email_verified: Optional[bool] = False
-    is_active: Optional[bool] = True
-    is_machine: Optional[bool] = False
-    user_data: Optional[Dict[str, Any]] = None
-
-
-class EmailPasswordAuthSchema(BaseModel):
-    email: str
-    password: str
-    auth_source: str = "cli"
-
-
-class TeamSchema(BaseModel):
-    """Schema for team data returned by the API."""
-
-    id_team: str
-    name: str
-    url: str
-
-
-class TeamIdentifier(BaseModel):
-    id_team: Optional[str] = None
-    team_url: Optional[str] = None

agno/api/schemas/workspace.py

@@ -1,46 +0,0 @@
-from typing import Any, Dict, Optional
-
-from pydantic import BaseModel
-
-
-class WorkspaceCreate(BaseModel):
-    ws_name: str
-    git_url: Optional[str] = None
-    visibility: Optional[str] = None
-    ws_data: Optional[Dict[str, Any]] = None
-
-
-class WorkspaceUpdate(BaseModel):
-    id_workspace: str
-    ws_name: Optional[str] = None
-    git_url: Optional[str] = None
-    visibility: Optional[str] = None
-    ws_data: Optional[Dict[str, Any]] = None
-    is_active: Optional[bool] = None
-
-
-class WorkspaceDelete(BaseModel):
-    id_workspace: str
-    ws_name: Optional[str] = None
-
-
-class WorkspaceEvent(BaseModel):
-    id_workspace: str
-    event_type: str
-    event_status: str
-    event_data: Optional[Dict[str, Any]] = None
-
-
-class WorkspaceSchema(BaseModel):
-    """Workspace data returned by the API."""
-
-    id_workspace: Optional[str] = None
-    ws_name: Optional[str] = None
-    is_active: Optional[bool] = None
-    git_url: Optional[str] = None
-    ws_data: Optional[Dict[str, Any]] = None
-
-
-class WorkspaceIdentifier(BaseModel):
-    ws_key: Optional[str] = None
-    id_workspace: Optional[str] = None

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)