agno 2.2.13__py3-none-any.whl

agno/api/agent.py

@@ -0,0 +1,28 @@
+from agno.api.api import api
+from agno.api.routes import ApiRoutes
+from agno.api.schemas.agent import AgentRunCreate
+from agno.utils.log import log_debug
+
+
+def create_agent_run(run: AgentRunCreate) -> None:
+    """Telemetry recording for Agent runs"""
+    with api.Client() as api_client:
+        try:
+            api_client.post(
+                ApiRoutes.RUN_CREATE,
+                json=run.model_dump(exclude_none=True),
+            )
+        except Exception as e:
+            log_debug(f"Could not create Agent run: {e}")
+
+
+async def acreate_agent_run(run: AgentRunCreate) -> None:
+    """Telemetry recording for async Agent runs"""
+    async with api.AsyncClient() as api_client:
+        try:
+            await api_client.post(
+                ApiRoutes.RUN_CREATE,
+                json=run.model_dump(exclude_none=True),
+            )
+        except Exception as e:
+            log_debug(f"Could not create Agent run: {e}")

agno/api/api.py

@@ -0,0 +1,40 @@
+from typing import Dict
+
+from httpx import AsyncClient as HttpxAsyncClient
+from httpx import Client as HttpxClient
+from httpx import Response
+
+from agno.api.settings import agno_api_settings
+
+
+class Api:
+    def __init__(self):
+        self.headers: Dict[str, str] = {
+            "user-agent": f"{agno_api_settings.app_name}/{agno_api_settings.app_version}",
+            "Content-Type": "application/json",
+        }
+
+    def Client(self) -> HttpxClient:
+        return HttpxClient(
+            base_url=agno_api_settings.api_url,
+            headers=self.headers,
+            timeout=60,
+        )
+
+    def AsyncClient(self) -> HttpxAsyncClient:
+        return HttpxAsyncClient(
+            base_url=agno_api_settings.api_url,
+            headers=self.headers,
+            timeout=60,
+        )
+
+
+api = Api()
+
+
+def invalid_response(r: Response) -> bool:
+    """Returns true if the response is invalid"""
+
+    if r.status_code >= 400:
+        return True
+    return False

agno/api/evals.py

@@ -0,0 +1,22 @@
+from agno.api.api import api
+from agno.api.routes import ApiRoutes
+from agno.api.schemas.evals import EvalRunCreate
+from agno.utils.log import log_debug
+
+
+def create_eval_run_telemetry(eval_run: EvalRunCreate) -> None:
+    """Telemetry recording for Eval runs"""
+    with api.Client() as api_client:
+        try:
+            api_client.post(ApiRoutes.EVAL_RUN_CREATE, json=eval_run.model_dump(exclude_none=True))
+        except Exception as e:
+            log_debug(f"Could not create evaluation run: {e}")
+
+
+async def async_create_eval_run_telemetry(eval_run: EvalRunCreate) -> None:
+    """Telemetry recording for async Eval runs"""
+    async with api.AsyncClient() as api_client:
+        try:
+            await api_client.post(ApiRoutes.EVAL_RUN_CREATE, json=eval_run.model_dump(exclude_none=True))
+        except Exception as e:
+            log_debug(f"Could not create evaluation run: {e}")

agno/api/os.py

@@ -0,0 +1,17 @@
+from agno.api.api import api
+from agno.api.routes import ApiRoutes
+from agno.api.schemas.os import OSLaunch
+from agno.utils.log import log_debug
+
+
+def log_os_telemetry(launch: OSLaunch) -> None:
+    """Telemetry recording for OS launches"""
+    with api.Client() as api_client:
+        try:
+            response = api_client.post(
+                ApiRoutes.AGENT_OS_LAUNCH,
+                json=launch.model_dump(exclude_none=True),
+            )
+            response.raise_for_status()
+        except Exception as e:
+            log_debug(f"Could not register OS launch for telemetry: {e}")

agno/api/routes.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class ApiRoutes:
+    """API routes for telemetry recordings"""
+
+    # Runs
+    RUN_CREATE: str = "/telemetry/runs"
+    EVAL_RUN_CREATE: str = "/telemetry/evals"
+
+    # OS launch
+    AGENT_OS_LAUNCH: str = "/telemetry/os"

agno/api/schemas/__init__.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+from agno.api.schemas.agent import AgentRunCreate
+from agno.api.schemas.evals import EvalRunCreate
+from agno.api.schemas.os import OSLaunch
+from agno.api.schemas.team import TeamRunCreate
+from agno.api.schemas.workflows import WorkflowRunCreate
+
+__all__ = ["AgentRunCreate", "OSLaunch", "EvalRunCreate", "TeamRunCreate", "WorkflowRunCreate"]

agno/api/schemas/agent.py

@@ -0,0 +1,16 @@
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, Field
+
+from agno.api.schemas.utils import TelemetryRunEventType, get_sdk_version
+
+
+class AgentRunCreate(BaseModel):
+    """Data sent to API to create an Agent Run"""
+
+    session_id: str
+    run_id: Optional[str] = None
+    data: Optional[Dict[Any, Any]] = None
+
+    sdk_version: str = Field(default_factory=get_sdk_version)
+    type: TelemetryRunEventType = TelemetryRunEventType.AGENT

agno/api/schemas/evals.py

@@ -0,0 +1,16 @@
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, Field
+
+from agno.api.schemas.utils import get_sdk_version
+from agno.db.schemas.evals import EvalType
+
+
+class EvalRunCreate(BaseModel):
+    """Data sent to the telemetry API to create an Eval run event"""
+
+    run_id: str
+    eval_type: EvalType
+    data: Optional[Dict[Any, Any]] = None
+
+    sdk_version: str = Field(default_factory=get_sdk_version)

agno/api/schemas/os.py

@@ -0,0 +1,14 @@
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, Field
+
+from agno.api.schemas.utils import get_sdk_version
+
+
+class OSLaunch(BaseModel):
+    """Data sent to API to create an OS Launch"""
+
+    os_id: Optional[str] = None
+    data: Optional[Dict[Any, Any]] = None
+
+    sdk_version: str = Field(default_factory=get_sdk_version)

agno/api/schemas/response.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel
+
+
+class ApiResponseSchema(BaseModel):
+    status: str = "fail"
+    message: str = "invalid request"

agno/api/schemas/team.py

@@ -0,0 +1,16 @@
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, Field
+
+from agno.api.schemas.utils import TelemetryRunEventType, get_sdk_version
+
+
+class TeamRunCreate(BaseModel):
+    """Data sent to API to create a Team Run"""
+
+    session_id: str
+    run_id: Optional[str] = None
+    data: Optional[Dict[Any, Any]] = None
+
+    sdk_version: str = Field(default_factory=get_sdk_version)
+    type: TelemetryRunEventType = TelemetryRunEventType.TEAM

agno/api/schemas/utils.py

@@ -0,0 +1,21 @@
+from enum import Enum
+
+
+class TelemetryRunEventType(str, Enum):
+    AGENT = "agent"
+    EVAL = "eval"
+    TEAM = "team"
+    WORKFLOW = "workflow"
+
+
+def get_sdk_version() -> str:
+    """Return the installed agno SDK version from package metadata.
+
+    Falls back to "unknown" if the package metadata isn't available.
+    """
+    from importlib.metadata import version as pkg_version
+
+    try:
+        return pkg_version("agno")
+    except Exception:
+        return "unknown"

agno/api/schemas/workflows.py

@@ -0,0 +1,16 @@
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, Field
+
+from agno.api.schemas.utils import TelemetryRunEventType, get_sdk_version
+
+
+class WorkflowRunCreate(BaseModel):
+    """Data sent to API to create a Workflow Run"""
+
+    session_id: str
+    run_id: Optional[str] = None
+    data: Optional[Dict[Any, Any]] = None
+
+    sdk_version: str = Field(default_factory=get_sdk_version)
+    type: TelemetryRunEventType = TelemetryRunEventType.WORKFLOW

agno/api/settings.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from importlib import metadata
+
+from pydantic import field_validator
+from pydantic_core.core_schema import ValidationInfo
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from agno.utils.log import logger
+
+
+class AgnoAPISettings(BaseSettings):
+    app_name: str = "agno"
+    app_version: str = metadata.version("agno")
+
+    api_runtime: str = "prd"
+    alpha_features: bool = False
+
+    api_url: str = "https://os-api.agno.com"
+
+    model_config = SettingsConfigDict(env_prefix="AGNO_")
+
+    @field_validator("api_runtime", mode="before")
+    def validate_runtime_env(cls, v):
+        """Validate api_runtime."""
+
+        valid_api_runtimes = ["dev", "stg", "prd"]
+        if v.lower() not in valid_api_runtimes:
+            raise ValueError(f"Invalid api_runtime: {v}")
+
+        return v.lower()
+
+    @field_validator("api_url", mode="before")
+    def update_api_url(cls, v, info: ValidationInfo):
+        api_runtime = info.data["api_runtime"]
+        if api_runtime == "dev":
+            from os import getenv
+
+            if getenv("AGNO_RUNTIME") == "docker":
+                return "http://host.docker.internal:7070"
+            return "http://localhost:7070"
+        elif api_runtime == "stg":
+            return "https://api-stg.agno.com"
+        else:
+            return "https://os-api.agno.com"
+
+    def gate_alpha_feature(self):
+        if not self.alpha_features:
+            logger.error("This is an Alpha feature not for general use.\nPlease message the Agno team for access.")
+            exit(1)
+
+
+agno_api_settings = AgnoAPISettings()

agno/api/team.py

@@ -0,0 +1,30 @@
+from agno.api.api import api
+from agno.api.routes import ApiRoutes
+from agno.api.schemas.team import TeamRunCreate
+from agno.utils.log import log_debug
+
+
+def create_team_run(run: TeamRunCreate) -> None:
+    """Telemetry recording for Team runs"""
+    with api.Client() as api_client:
+        try:
+            response = api_client.post(
+                ApiRoutes.RUN_CREATE,
+                json=run.model_dump(exclude_none=True),
+            )
+            response.raise_for_status()
+        except Exception as e:
+            log_debug(f"Could not create Team run: {e}")
+
+
+async def acreate_team_run(run: TeamRunCreate) -> None:
+    """Telemetry recording for async Team runs"""
+    async with api.AsyncClient() as api_client:
+        try:
+            response = await api_client.post(
+                ApiRoutes.RUN_CREATE,
+                json=run.model_dump(exclude_none=True),
+            )
+            response.raise_for_status()
+        except Exception as e:
+            log_debug(f"Could not create Team run: {e}")

agno/api/workflow.py

@@ -0,0 +1,28 @@
+from agno.api.api import api
+from agno.api.routes import ApiRoutes
+from agno.api.schemas.workflows import WorkflowRunCreate
+from agno.utils.log import log_debug
+
+
+def create_workflow_run(workflow: WorkflowRunCreate) -> None:
+    """Telemetry recording for Workflow runs"""
+    with api.Client() as api_client:
+        try:
+            api_client.post(
+                ApiRoutes.RUN_CREATE,
+                json=workflow.model_dump(exclude_none=True),
+            )
+        except Exception as e:
+            log_debug(f"Could not create Workflow: {e}")
+
+
+async def acreate_workflow_run(workflow: WorkflowRunCreate) -> None:
+    """Telemetry recording for async Workflow runs"""
+    async with api.AsyncClient() as api_client:
+        try:
+            await api_client.post(
+                ApiRoutes.RUN_CREATE,
+                json=workflow.model_dump(exclude_none=True),
+            )
+        except Exception as e:
+            log_debug(f"Could not create Team: {e}")

agno/cloud/aws/base.py

@@ -0,0 +1,214 @@
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+from agno.cloud.aws.s3.api_client import AwsApiClient
+from agno.utils.log import logger
+
+
+class AwsResource(BaseModel):
+    """Base class for AWS Resources."""
+
+    # Resource name (required)
+    name: str
+
+    # Resource type
+    resource_type: Optional[str] = None
+    active_resource: Optional[Any] = None
+
+    skip_delete: bool = False
+    skip_create: bool = False
+    skip_read: bool = False
+    skip_update: bool = False
+
+    wait_for_create: bool = True
+    wait_for_update: bool = True
+    wait_for_delete: bool = True
+    waiter_delay: int = 30
+    waiter_max_attempts: int = 50
+    save_output: bool = False
+    use_cache: bool = True
+
+    service_name: str
+    service_client: Optional[Any] = None
+    service_resource: Optional[Any] = None
+
+    aws_region: Optional[str] = None
+    aws_profile: Optional[str] = None
+
+    aws_client: Optional[AwsApiClient] = None
+
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+
+    def get_resource_name(self) -> str:
+        return self.name or self.__class__.__name__
+
+    def get_resource_type(self) -> str:
+        if self.resource_type is None:
+            return self.__class__.__name__
+        return self.resource_type
+
+    def get_service_client(self, aws_client: AwsApiClient):
+        from boto3 import session
+
+        if self.service_client is None:
+            boto3_session: session = aws_client.boto3_session
+            self.service_client = boto3_session.client(service_name=self.service_name)
+        return self.service_client
+
+    def get_service_resource(self, aws_client: AwsApiClient):
+        from boto3 import session
+
+        if self.service_resource is None:
+            boto3_session: session = aws_client.boto3_session
+            self.service_resource = boto3_session.resource(service_name=self.service_name)
+        return self.service_resource
+
+    def get_aws_region(self) -> Optional[str]:
+        if self.aws_region:
+            return self.aws_region
+
+        from os import getenv
+
+        aws_region_env = getenv("AWS_REGION")
+        if aws_region_env is not None:
+            logger.debug(f"{'AWS_REGION'}: {aws_region_env}")
+            self.aws_region = aws_region_env
+        return self.aws_region
+
+    def get_aws_profile(self) -> Optional[str]:
+        if self.aws_profile:
+            return self.aws_profile
+
+        from os import getenv
+
+        aws_profile_env = getenv("AWS_PROFILE")
+        if aws_profile_env is not None:
+            logger.debug(f"{'AWS_PROFILE'}: {aws_profile_env}")
+            self.aws_profile = aws_profile_env
+        return self.aws_profile
+
+    def get_aws_client(self) -> AwsApiClient:
+        if self.aws_client is not None:
+            return self.aws_client
+        self.aws_client = AwsApiClient(aws_region=self.get_aws_region(), aws_profile=self.get_aws_profile())
+        return self.aws_client
+
+    def _read(self, aws_client: AwsApiClient) -> Any:
+        logger.warning(f"@_read method not defined for {self.get_resource_name()}")
+        return True
+
+    def read(self, aws_client: Optional[AwsApiClient] = None) -> Any:
+        """Reads the resource from Aws"""
+        # Step 1: Use cached value if available
+        if self.use_cache and self.active_resource is not None:
+            return self.active_resource
+
+        # Step 2: Skip resource creation if skip_read = True
+        if self.skip_read:
+            print(f"Skipping read: {self.get_resource_name()}")
+            return True
+
+        # Step 3: Read resource
+        client: AwsApiClient = aws_client or self.get_aws_client()
+        return self._read(client)
+
+    def is_active(self, aws_client: AwsApiClient) -> bool:
+        """Returns True if the resource is active on Aws"""
+        _resource = self.read(aws_client=aws_client)
+        return True if _resource is not None else False
+
+    def _create(self, aws_client: AwsApiClient) -> bool:
+        logger.warning(f"@_create method not defined for {self.get_resource_name()}")
+        return True
+
+    def create(self, aws_client: Optional[AwsApiClient] = None) -> bool:
+        """Creates the resource on Aws"""
+
+        # Step 1: Skip resource creation if skip_create = True
+        if self.skip_create:
+            print(f"Skipping create: {self.get_resource_name()}")
+            return True
+
+        # Step 2: Check if resource is active and use_cache = True
+        client: AwsApiClient = aws_client or self.get_aws_client()
+        if self.use_cache and self.is_active(client):
+            self.resource_created = True
+            print(f"{self.get_resource_type()}: {self.get_resource_name()} already exists")
+        # Step 3: Create the resource
+        else:
+            self.resource_created = self._create(client)
+            if self.resource_created:
+                print(f"{self.get_resource_type()}: {self.get_resource_name()} created")
+
+        # Step 4: Run post create steps
+        if self.resource_created:
+            logger.debug(f"Running post-create for {self.get_resource_type()}: {self.get_resource_name()}")
+            return self.post_create(client)
+        logger.error(f"Failed to create {self.get_resource_type()}: {self.get_resource_name()}")
+        return self.resource_created
+
+    def post_create(self, aws_client: AwsApiClient) -> bool:
+        return True
+
+    def _update(self, aws_client: AwsApiClient) -> Any:
+        logger.warning(f"@_update method not defined for {self.get_resource_name()}")
+        return True
+
+    def update(self, aws_client: Optional[AwsApiClient] = None) -> bool:
+        """Updates the resource on Aws"""
+
+        # Step 1: Skip resource update if skip_update = True
+        if self.skip_update:
+            print(f"Skipping update: {self.get_resource_name()}")
+            return True
+
+        # Step 2: Update the resource
+        client: AwsApiClient = aws_client or self.get_aws_client()
+        if self.is_active(client):
+            self.resource_updated = self._update(client)
+        else:
+            print(f"{self.get_resource_type()}: {self.get_resource_name()} does not exist")
+            return True
+
+        # Step 3: Run post update steps
+        if self.resource_updated:
+            print(f"{self.get_resource_type()}: {self.get_resource_name()} updated")
+            logger.debug(f"Running post-update for {self.get_resource_type()}: {self.get_resource_name()}")
+            return self.post_update(client)
+        logger.error(f"Failed to update {self.get_resource_type()}: {self.get_resource_name()}")
+        return self.resource_updated
+
+    def post_update(self, aws_client: AwsApiClient) -> bool:
+        return True
+
+    def _delete(self, aws_client: AwsApiClient) -> Any:
+        logger.warning(f"@_delete method not defined for {self.get_resource_name()}")
+        return True
+
+    def delete(self, aws_client: Optional[AwsApiClient] = None) -> bool:
+        """Deletes the resource from Aws"""
+
+        # Step 1: Skip resource deletion if skip_delete = True
+        if self.skip_delete:
+            print(f"Skipping delete: {self.get_resource_name()}")
+            return True
+
+        # Step 2: Delete the resource
+        client: AwsApiClient = aws_client or self.get_aws_client()
+        if self.is_active(client):
+            self.resource_deleted = self._delete(client)
+        else:
+            print(f"{self.get_resource_type()}: {self.get_resource_name()} does not exist")
+            return True
+
+        # Step 3: Run post delete steps
+        if self.resource_deleted:
+            print(f"{self.get_resource_type()}: {self.get_resource_name()} deleted")
+            logger.debug(f"Running post-delete for {self.get_resource_type()}: {self.get_resource_name()}.")
+            return self.post_delete(client)
+        logger.error(f"Failed to delete {self.get_resource_type()}: {self.get_resource_name()}")
+        return self.resource_deleted
+
+    def post_delete(self, aws_client: AwsApiClient) -> bool:
+        return True

agno/cloud/aws/s3/__init__.py

@@ -0,0 +1,2 @@
+from agno.cloud.aws.s3.bucket import S3Bucket
+from agno.cloud.aws.s3.object import S3Object

agno/cloud/aws/s3/api_client.py

@@ -0,0 +1,43 @@
+from typing import Any, Optional
+
+from agno.utils.log import logger
+
+
+class AwsApiClient:
+    def __init__(
+        self,
+        aws_region: Optional[str] = None,
+        aws_profile: Optional[str] = None,
+    ):
+        super().__init__()
+        self.aws_region: Optional[str] = aws_region
+        self.aws_profile: Optional[str] = aws_profile
+
+        # aws boto3 session
+        self._boto3_session: Optional[Any] = None
+        logger.debug("**-+-** AwsApiClient created")
+
+    def create_boto3_session(self) -> Optional[Any]:
+        """Create a boto3 session"""
+        import boto3
+
+        logger.debug("Creating boto3.Session")
+        try:
+            self._boto3_session = boto3.Session(
+                region_name=self.aws_region,
+                profile_name=self.aws_profile,
+            )
+            logger.debug("**-+-** boto3.Session created")
+            logger.debug(f"\taws_region: {self._boto3_session.region_name}")
+            logger.debug(f"\taws_profile: {self._boto3_session.profile_name}")
+        except Exception as e:
+            logger.error("Could not connect to aws. Please confirm aws cli is installed and configured")
+            logger.error(e)
+            exit(0)
+        return self._boto3_session
+
+    @property
+    def boto3_session(self) -> Optional[Any]:
+        if self._boto3_session is None:
+            self._boto3_session = self.create_boto3_session()
+        return self._boto3_session