agno 0.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/api/agent.py

@@ -1,67 +1,28 @@
 from agno.api.api import api
 from agno.api.routes import ApiRoutes
-from agno.api.schemas.agent import AgentRunCreate, AgentSessionCreate
-from agno.cli.settings import agno_cli_settings
-from agno.utils.log import logger
+from agno.api.schemas.agent import AgentRunCreate
+from agno.utils.log import log_debug
 
 
-def create_agent_session(session: AgentSessionCreate, monitor: bool = False) -> None:
-    if not agno_cli_settings.api_enabled:
-        return
-
-    logger.debug("--**-- Logging Agent Session")
-    with api.AuthenticatedClient() as api_client:
-        try:
-            api_client.post(
-                ApiRoutes.AGENT_SESSION_CREATE if monitor else ApiRoutes.AGENT_TELEMETRY_SESSION_CREATE,
-                json={"session": session.model_dump(exclude_none=True)},
-            )
-        except Exception as e:
-            logger.debug(f"Could not create Agent session: {e}")
-    return
-
-
-def create_agent_run(run: AgentRunCreate, monitor: bool = False) -> None:
-    if not agno_cli_settings.api_enabled:
-        return
-
-    logger.debug("--**-- Logging Agent Run")
-    with api.AuthenticatedClient() as api_client:
+def create_agent_run(run: AgentRunCreate) -> None:
+    """Telemetry recording for Agent runs"""
+    with api.Client() as api_client:
         try:
             api_client.post(
-                ApiRoutes.AGENT_RUN_CREATE if monitor else ApiRoutes.AGENT_TELEMETRY_RUN_CREATE,
-                json={"run": run.model_dump(exclude_none=True)},
+                ApiRoutes.RUN_CREATE,
+                json=run.model_dump(exclude_none=True),
             )
         except Exception as e:
-            logger.debug(f"Could not create Agent run: {e}")
-    return
-
-
-async def acreate_agent_session(session: AgentSessionCreate, monitor: bool = False) -> None:
-    if not agno_cli_settings.api_enabled:
-        return
-
-    logger.debug("--**-- Logging Agent Session (Async)")
-    async with api.AuthenticatedAsyncClient() as api_client:
-        try:
-            await api_client.post(
-                ApiRoutes.AGENT_SESSION_CREATE if monitor else ApiRoutes.AGENT_TELEMETRY_SESSION_CREATE,
-                json={"session": session.model_dump(exclude_none=True)},
-            )
-        except Exception as e:
-            logger.debug(f"Could not create Agent session: {e}")
-
+            log_debug(f"Could not create Agent run: {e}")
 
-async def acreate_agent_run(run: AgentRunCreate, monitor: bool = False) -> None:
-    if not agno_cli_settings.api_enabled:
-        return
 
-    logger.debug("--**-- Logging Agent Run (Async)")
-    async with api.AuthenticatedAsyncClient() as api_client:
+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.AGENT_RUN_CREATE if monitor else ApiRoutes.AGENT_TELEMETRY_RUN_CREATE,
-                json={"run": run.model_dump(exclude_none=True)},
+                ApiRoutes.RUN_CREATE,
+                json=run.model_dump(exclude_none=True),
             )
         except Exception as e:
-            logger.debug(f"Could not create Agent run: {e}")
+            log_debug(f"Could not create Agent run: {e}")

agno/api/api.py

@@ -1,72 +1,33 @@
-from os import getenv
-from typing import Dict, Optional
+from typing import Dict
 
 from httpx import AsyncClient as HttpxAsyncClient
 from httpx import Client as HttpxClient
 from httpx import Response
 
-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
+from agno.api.settings import agno_api_settings
 
 
 class Api:
     def __init__(self):
         self.headers: Dict[str, str] = {
-            "user-agent": f"{agno_cli_settings.app_name}/{agno_cli_settings.app_version}",
+            "user-agent": f"{agno_api_settings.app_name}/{agno_api_settings.app_version}",
             "Content-Type": "application/json",
         }
-        self._auth_token: Optional[str] = None
-        self._authenticated_headers = None
-
-    @property
-    def auth_token(self) -> Optional[str]:
-        if self._auth_token is None:
-            try:
-                self._auth_token = read_auth_token()
-            except Exception as e:
-                logger.debug(f"Failed to read auth token: {e}")
-        return self._auth_token
-
-    @property
-    def authenticated_headers(self) -> Dict[str, str]:
-        if self._authenticated_headers is None:
-            self._authenticated_headers = self.headers.copy()
-            token = self.auth_token
-            if token is not None:
-                self._authenticated_headers[agno_cli_settings.auth_token_header] = token
-            agno_api_key = getenv(AGNO_API_KEY_ENV_VAR)
-            if agno_api_key is not None:
-                self._authenticated_headers["Authorization"] = f"Bearer {agno_api_key}"
-        return self._authenticated_headers
 
     def Client(self) -> HttpxClient:
         return HttpxClient(
-            base_url=agno_cli_settings.api_url,
+            base_url=agno_api_settings.api_url,
             headers=self.headers,
             timeout=60,
-        )
-
-    def AuthenticatedClient(self) -> HttpxClient:
-        return HttpxClient(
-            base_url=agno_cli_settings.api_url,
-            headers=self.authenticated_headers,
-            timeout=60,
+            http2=True,
         )
 
     def AsyncClient(self) -> HttpxAsyncClient:
         return HttpxAsyncClient(
-            base_url=agno_cli_settings.api_url,
+            base_url=agno_api_settings.api_url,
             headers=self.headers,
             timeout=60,
-        )
-
-    def AuthenticatedAsyncClient(self) -> HttpxAsyncClient:
-        return HttpxAsyncClient(
-            base_url=agno_cli_settings.api_url,
-            headers=self.authenticated_headers,
-            timeout=60,
+            http2=True,
         )
 
 

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

@@ -3,30 +3,11 @@ from dataclasses import dataclass
 
 @dataclass
 class ApiRoutes:
-    # User paths
-    USER_HEALTH: str = "/v1/user/health"
-    USER_SIGN_IN: str = "/v1/user/signin"
-    USER_CLI_AUTH: str = "/v1/user/cliauth"
-    USER_AUTHENTICATE: str = "/v1/user/authenticate"
-    USER_CREATE_ANON: str = "/v1/user/create/anon"
+    """API routes for telemetry recordings"""
 
-    # Workspace paths
-    WORKSPACE_CREATE: str = "/v1/workspace/create"
-    WORKSPACE_UPDATE: str = "/v1/workspace/update"
-    WORKSPACE_DELETE: str = "/v1/workspace/delete"
-    WORKSPACE_EVENT_CREATE: str = "/v1/workspace/event/create"
+    # Runs
+    RUN_CREATE: str = "/telemetry/runs"
+    EVAL_RUN_CREATE: str = "/telemetry/evals"
 
-    # Team paths
-    TEAM_READ_ALL: str = "/v1/team/read/all"
-
-    # Agent paths
-    AGENT_SESSION_CREATE: str = "/v1/agent/session/create"
-    AGENT_RUN_CREATE: str = "/v1/agent/run/create"
-
-    # Telemetry paths
-    AGENT_TELEMETRY_SESSION_CREATE: str = "/v1/telemetry/agent/session/create"
-    AGENT_TELEMETRY_RUN_CREATE: str = "/v1/telemetry/agent/run/create"
-
-    # Playground paths
-    PLAYGROUND_ENDPOINT_CREATE: str = "/v1/playground/endpoint/create"
-    PLAYGROUND_APP_DEPLOY: str = "/v1/playground/app/deploy"
+    # 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

@@ -1,13 +1,8 @@
 from typing import Any, Dict, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
-
-class AgentSessionCreate(BaseModel):
-    """Data sent to API to create an Agent Session"""
-
-    session_id: str
-    agent_data: Optional[Dict[str, Any]] = None
+from agno.api.schemas.utils import TelemetryRunEventType, get_sdk_version
 
 
 class AgentRunCreate(BaseModel):
@@ -15,5 +10,7 @@ class AgentRunCreate(BaseModel):
 
     session_id: str
     run_id: Optional[str] = None
-    run_data: Optional[Dict[str, Any]] = None
-    agent_data: Optional[Dict[str, Any]] = 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/team.py

@@ -1,16 +1,16 @@
-from typing import Optional
+from typing import Any, Dict, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
+from agno.api.schemas.utils import TelemetryRunEventType, get_sdk_version
 
-class TeamSchema(BaseModel):
-    """Schema for team data returned by the API."""
 
-    id_team: str
-    name: str
-    url: str
+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
 
-class TeamIdentifier(BaseModel):
-    id_team: Optional[str] = None
-    team_url: Optional[str] = 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

@@ -1,34 +1,30 @@
-from typing import Dict, List, Optional
-
-from httpx import Response
-
-from agno.api.api import api, invalid_response
+from agno.api.api import api
 from agno.api.routes import ApiRoutes
-from agno.api.schemas.team import TeamSchema
-from agno.api.schemas.user import UserSchema
-from agno.utils.log import logger
+from agno.api.schemas.team import TeamRunCreate
+from agno.utils.log import log_debug
 
 
-def get_teams_for_user(user: UserSchema) -> Optional[List[TeamSchema]]:
-    logger.debug("--**-- Reading teams for user")
-    with api.AuthenticatedClient() as api_client:
+def create_team_run(run: TeamRunCreate) -> None:
+    """Telemetry recording for Team runs"""
+    with api.Client() 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,
+            response = api_client.post(
+                ApiRoutes.RUN_CREATE,
+                json=run.model_dump(exclude_none=True),
             )
-            if invalid_response(r):
-                return None
+            response.raise_for_status()
+        except Exception as e:
+            log_debug(f"Could not create Team run: {e}")
 
-            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
+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:
-            logger.debug(f"Could not read teams: {e}")
-    return None
+            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}")