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

agno/api/agent.py

@@ -1,84 +1,28 @@
 from agno.api.api import api
 from agno.api.routes import ApiRoutes
-from agno.api.schemas.agent import AgentCreate, AgentRunCreate, AgentSessionCreate
-from agno.cli.settings import agno_cli_settings
+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
-
-    log_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:
-            log_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
-
-    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:
             log_debug(f"Could not create Agent run: {e}")
-    return
-
 
-async def acreate_agent_run(run: AgentRunCreate, monitor: bool = False) -> None:
-    if not agno_cli_settings.api_enabled:
-        return
 
-    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:
             log_debug(f"Could not create Agent run: {e}")
-    return
-
-
-def create_agent(agent: AgentCreate) -> None:
-    if not agno_cli_settings.api_enabled:
-        return
-
-    with api.AuthenticatedClient() as api_client:
-        try:
-            api_client.post(
-                ApiRoutes.AGENT_CREATE,
-                json=agent.model_dump(exclude_none=True),
-            )
-
-            log_debug(f"Created Agent on Platform. ID: {agent.agent_id}")
-        except Exception as e:
-            log_debug(f"Could not create Agent: {e}")
-    return
-
-
-async def acreate_agent(agent: AgentCreate) -> None:
-    if not agno_cli_settings.api_enabled:
-        return
-
-    async with api.AuthenticatedAsyncClient() as api_client:
-        try:
-            await api_client.post(
-                ApiRoutes.AGENT_CREATE,
-                json=agent.model_dump(exclude_none=True),
-            )
-            log_debug(f"Created Agent on Platform. ID: {agent.agent_id}")
-        except Exception as e:
-            log_debug(f"Could not create Agent: {e}")
-    return

agno/api/api.py

@@ -1,74 +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,
-        )
-
     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,
-        )
-
 
 api = Api()
 

agno/api/evals.py

@@ -1,33 +1,22 @@
 from agno.api.api import api
 from agno.api.routes import ApiRoutes
 from agno.api.schemas.evals import EvalRunCreate
-from agno.cli.settings import agno_cli_settings
 from agno.utils.log import log_debug
 
 
-def create_eval_run(eval_run: EvalRunCreate) -> None:
-    """Call the API to create an evaluation run."""
-    if not agno_cli_settings.api_enabled:
-        return
-
-    log_debug("Calling the API to create an evaluation run")
-    with api.AuthenticatedClient() as api_client:
+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": eval_run.model_dump(exclude_none=True)})
+            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}")
-    return
-
 
-async def async_create_eval_run(eval_run: EvalRunCreate) -> None:
-    """Call the API to create an evaluation run."""
-    if not agno_cli_settings.api_enabled:
-        return
 
-    log_debug("Calling the API to create an evaluation run")
-    async with api.AuthenticatedAsyncClient() as api_client:
+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": eval_run.model_dump(exclude_none=True)})
+            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}")
-    return

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 create OS launch: {e}")

agno/api/routes.py

@@ -3,46 +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-sessions"
-    AGENT_RUN_CREATE: str = "/v1/agent-runs"
-    AGENT_CREATE: str = "/v2/agents"
-
-    # App paths
-    APP_CREATE: str = "/v2/apps"
-    # Team paths
-    TEAM_RUN_CREATE: str = "/v1/team-runs"
-    TEAM_SESSION_CREATE: str = "/v1/team-sessions"
-    TEAM_CREATE: str = "/v2/teams"
-
-    # Workflow paths
-    WORKFLOW_CREATE: str = "/v2/workflows"
-    # Telemetry paths
-    # TODO: Update to use the new telemetry paths
-    AGENT_TELEMETRY_SESSION_CREATE: str = "/v1/telemetry/agent/session/create"
-    AGENT_TELEMETRY_RUN_CREATE: str = "/v1/telemetry/agent/run/create"
-
-    TEAM_TELEMETRY_RUN_CREATE: str = "/v1/telemetry/team-runs"
-
-    # Playground paths
-    PLAYGROUND_ENDPOINT_CREATE: str = "/v1/playground/endpoint/create"
-    PLAYGROUND_APP_DEPLOY: str = "/v1/playground/app/deploy"
-
-    # Eval paths
-    EVAL_RUN_CREATE: str = "/v2/eval-runs"
+    # 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,32 +1,16 @@
 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):
     """Data sent to API to create an Agent Run"""
 
     session_id: str
-    team_session_id: Optional[str] = None
-    workflow_session_id: Optional[str] = None
     run_id: Optional[str] = None
-    run_data: Optional[Dict[str, Any]] = None
-    agent_data: Optional[Dict[str, Any]] = None
-
-
-class AgentCreate(BaseModel):
-    """Data sent to API to create an Agent"""
+    data: Optional[Dict[Any, Any]] = None
 
-    agent_id: str
-    team_id: Optional[str] = None
-    app_id: Optional[str] = None
-    workflow_id: Optional[str] = None
-    name: Optional[str] = None
-    config: Dict[str, Any]
+    sdk_version: str = Field(default_factory=get_sdk_version)
+    type: TelemetryRunEventType = TelemetryRunEventType.AGENT

agno/api/schemas/evals.py

@@ -1,25 +1,16 @@
-from enum import Enum
 from typing import Any, Dict, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
-
-class EvalType(str, Enum):
-    ACCURACY = "accuracy"
-    PERFORMANCE = "performance"
-    RELIABILITY = "reliability"
+from agno.api.schemas.utils import get_sdk_version
+from agno.db.schemas.evals import EvalType
 
 
 class EvalRunCreate(BaseModel):
-    """Data sent to the API to create an evaluation run"""
-
-    agent_id: Optional[str] = None
-    model_id: Optional[str] = None
-    model_provider: Optional[str] = None
-    team_id: Optional[str] = None
-    name: Optional[str] = None
-    evaluated_entity_name: Optional[str] = None
+    """Data sent to the telemetry API to create an Eval run event"""
 
     run_id: str
     eval_type: EvalType
-    eval_data: Dict[str, Any]
+    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,32 +1,16 @@
 from typing import Any, Dict, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
-
-class TeamSessionCreate(BaseModel):
-    """Data sent to API to create a Team Session"""
-
-    session_id: str
-    team_data: Optional[Dict[str, Any]] = None
+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
-    team_session_id: Optional[str] = None
-    workflow_session_id: Optional[str] = None
     run_id: Optional[str] = None
-    run_data: Optional[Dict[str, Any]] = None
-    team_data: Optional[Dict[str, Any]] = None
-
-
-class TeamCreate(BaseModel):
-    """Data sent to API to create aTeam"""
+    data: Optional[Dict[Any, Any]] = None
 
-    team_id: str
-    parent_team_id: Optional[str] = None
-    app_id: Optional[str] = None
-    workflow_id: Optional[str] = None
-    name: Optional[str] = None
-    config: Dict[str, Any]
+    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

@@ -1,12 +1,16 @@
 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 WorkflowCreate(BaseModel):
-    """Data sent to API to create aWorkflow"""
 
-    workflow_id: str
-    app_id: Optional[str] = None
-    name: Optional[str] = None
-    config: Dict[str, Any]
+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,85 +1,30 @@
 from agno.api.api import api
 from agno.api.routes import ApiRoutes
-from agno.api.schemas.team import TeamCreate, TeamRunCreate, TeamSessionCreate
-from agno.cli.settings import agno_cli_settings
+from agno.api.schemas.team import TeamRunCreate
 from agno.utils.log import log_debug
 
 
-def create_team_run(run: TeamRunCreate, monitor: bool = False) -> None:
-    if not agno_cli_settings.api_enabled:
-        return
-
-    log_debug("--**-- Logging Team Run")
-    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:
             response = api_client.post(
-                ApiRoutes.TEAM_RUN_CREATE if monitor else ApiRoutes.TEAM_TELEMETRY_RUN_CREATE,
-                json={"run": run.model_dump(exclude_none=True)},
+                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}")
-    return
-
 
-async def acreate_team_run(run: TeamRunCreate, monitor: bool = False) -> None:
-    if not agno_cli_settings.api_enabled:
-        return
 
-    log_debug("--**-- Logging Team Run")
-    async with api.AuthenticatedAsyncClient() as api_client:
+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.TEAM_RUN_CREATE if monitor else ApiRoutes.TEAM_TELEMETRY_RUN_CREATE,
-                json={"run": run.model_dump(exclude_none=True)},
+                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}")
-
-
-def upsert_team_session(session: TeamSessionCreate, monitor: bool = False) -> None:
-    if not agno_cli_settings.api_enabled:
-        return
-
-    log_debug("--**-- Logging Team Session")
-    with api.AuthenticatedClient() as api_client:
-        try:
-            if monitor:
-                api_client.post(
-                    ApiRoutes.TEAM_SESSION_CREATE,
-                    json={"session": session.model_dump(exclude_none=True)},
-                )
-        except Exception as e:
-            log_debug(f"Could not create Agent session: {e}")
-    return
-
-
-def create_team(team: TeamCreate) -> None:
-    if not agno_cli_settings.api_enabled:
-        return
-
-    with api.AuthenticatedClient() as api_client:
-        try:
-            api_client.post(
-                ApiRoutes.TEAM_CREATE,
-                json=team.model_dump(exclude_none=True),
-            )
-        except Exception as e:
-            log_debug(f"Could not create Team: {e}")
-
-
-async def acreate_team(team: TeamCreate) -> None:
-    if not agno_cli_settings.api_enabled:
-        return
-
-    async with api.AuthenticatedAsyncClient() as api_client:
-        try:
-            await api_client.post(
-                ApiRoutes.TEAM_CREATE,
-                json=team.model_dump(exclude_none=True),
-            )
-        except Exception as e:
-            print(f"Could not create Team: {e}")
-
-            log_debug(f"Could not create Team: {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}")