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

agno/db/sqlite/utils.py

@@ -0,0 +1,269 @@
+import json
+import time
+from datetime import date, datetime, timedelta, timezone
+from typing import Any, Dict, List, Optional
+from uuid import uuid4
+
+from agno.db.sqlite.schemas import get_table_schema_definition
+from agno.utils.log import log_debug, log_error, log_warning
+
+try:
+    from sqlalchemy import Table
+    from sqlalchemy.dialects import sqlite
+    from sqlalchemy.engine import Engine
+    from sqlalchemy.inspection import inspect
+    from sqlalchemy.orm import Session
+    from sqlalchemy.sql.expression import text
+except ImportError:
+    raise ImportError("`sqlalchemy` not installed. Please install it using `pip install sqlalchemy`")
+
+
+# -- DB util methods --
+
+
+def apply_sorting(stmt, table: Table, sort_by: Optional[str] = None, sort_order: Optional[str] = None):
+    """Apply sorting to the given SQLAlchemy statement.
+    Args:
+        stmt: The SQLAlchemy statement to modify
+        table: The table being queried
+        sort_by: The field to sort by
+        sort_order: The sort order ('asc' or 'desc')
+    Returns:
+        The modified statement with sorting applied
+    """
+    if sort_by is None:
+        return stmt
+    if not hasattr(table.c, sort_by):
+        log_debug(f"Invalid sort field: '{sort_by}'. Will not apply any sorting.")
+        return stmt
+
+    # Apply the given sorting
+    sort_column = getattr(table.c, sort_by)
+    if sort_order and sort_order == "asc":
+        return stmt.order_by(sort_column.asc())
+    else:
+        return stmt.order_by(sort_column.desc())
+
+
+def is_table_available(session: Session, table_name: str, db_schema: Optional[str] = None) -> bool:
+    """
+    Check if a table with the given name exists.
+    Note: db_schema parameter is ignored in SQLite but kept for API compatibility.
+    Returns:
+        bool: True if the table exists, False otherwise.
+    """
+    try:
+        # SQLite uses sqlite_master instead of information_schema
+        exists_query = text("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = :table")
+        exists = session.execute(exists_query, {"table": table_name}).scalar() is not None
+        if not exists:
+            log_debug(f"Table {table_name} {'exists' if exists else 'does not exist'}")
+        return exists
+    except Exception as e:
+        log_error(f"Error checking if table exists: {e}")
+        return False
+
+
+def is_valid_table(db_engine: Engine, table_name: str, table_type: str, db_schema: Optional[str] = None) -> bool:
+    """
+    Check if the existing table has the expected column names.
+    Note: db_schema parameter is ignored in SQLite but kept for API compatibility.
+    Args:
+        db_engine (Engine): Database engine
+        table_name (str): Name of the table to validate
+        table_type (str): Type of table to get expected schema
+        db_schema (Optional[str]): Database schema name (ignored in SQLite)
+    Returns:
+        bool: True if table has all expected columns, False otherwise
+    """
+    try:
+        expected_table_schema = get_table_schema_definition(table_type)
+        expected_columns = {col_name for col_name in expected_table_schema.keys() if not col_name.startswith("_")}
+
+        # Get existing columns (no schema parameter for SQLite)
+        inspector = inspect(db_engine)
+        existing_columns_info = inspector.get_columns(table_name)  # No schema parameter
+        existing_columns = set(col["name"] for col in existing_columns_info)
+
+        # Check if all expected columns exist
+        missing_columns = expected_columns - existing_columns
+        if missing_columns:
+            log_warning(f"Missing columns {missing_columns} in table {table_name}")
+            return False
+
+        log_debug(f"Table {table_name} has all expected columns")
+        return True
+    except Exception as e:
+        log_error(f"Error validating table schema for {table_name}: {e}")
+        return False
+
+
+# -- Metrics util methods --
+
+
+def bulk_upsert_metrics(session: Session, table: Table, metrics_records: list[dict]) -> list[dict]:
+    """Bulk upsert metrics into the database.
+
+    Args:
+        table (Table): The table to upsert into.
+        metrics_records (list[dict]): The metrics records to upsert.
+
+    Returns:
+        list[dict]: The upserted metrics records.
+    """
+    if not metrics_records:
+        return []
+
+    results = []
+    stmt = sqlite.insert(table)
+
+    # Columns to update in case of conflict
+    update_columns = {
+        col.name: stmt.excluded[col.name]
+        for col in table.columns
+        if col.name not in ["id", "date", "created_at", "aggregation_period"]
+    }
+
+    stmt = stmt.on_conflict_do_update(index_elements=["date", "aggregation_period"], set_=update_columns).returning(  # type: ignore
+        table
+    )
+    result = session.execute(stmt, metrics_records)
+    results = [row._mapping for row in result.fetchall()]
+    session.commit()
+
+    return results  # type: ignore
+
+
+def calculate_date_metrics(date_to_process: date, sessions_data: dict) -> dict:
+    """Calculate metrics for the given single date.
+
+    Args:
+        date_to_process (date): The date to calculate metrics for.
+        sessions_data (dict): The sessions data to calculate metrics for.
+
+    Returns:
+        dict: The calculated metrics.
+    """
+    metrics = {
+        "users_count": 0,
+        "agent_sessions_count": 0,
+        "team_sessions_count": 0,
+        "workflow_sessions_count": 0,
+        "agent_runs_count": 0,
+        "team_runs_count": 0,
+        "workflow_runs_count": 0,
+    }
+    token_metrics = {
+        "input_tokens": 0,
+        "output_tokens": 0,
+        "total_tokens": 0,
+        "audio_total_tokens": 0,
+        "audio_input_tokens": 0,
+        "audio_output_tokens": 0,
+        "cache_read_tokens": 0,
+        "cache_write_tokens": 0,
+        "reasoning_tokens": 0,
+    }
+    model_counts: Dict[str, int] = {}
+
+    session_types = [
+        ("agent", "agent_sessions_count", "agent_runs_count"),
+        ("team", "team_sessions_count", "team_runs_count"),
+        ("workflow", "workflow_sessions_count", "workflow_runs_count"),
+    ]
+    all_user_ids = set()
+
+    for session_type, sessions_count_key, runs_count_key in session_types:
+        sessions = sessions_data.get(session_type, [])
+        metrics[sessions_count_key] = len(sessions)
+
+        for session in sessions:
+            if session.get("user_id"):
+                all_user_ids.add(session["user_id"])
+            metrics[runs_count_key] += len(session.get("runs", []))
+            if runs := session.get("runs", []):
+                runs = json.loads(runs)
+                for run in runs:
+                    if model_id := run.get("model"):
+                        model_provider = run.get("model_provider", "")
+                        model_counts[f"{model_id}:{model_provider}"] = (
+                            model_counts.get(f"{model_id}:{model_provider}", 0) + 1
+                        )
+
+            session_data = json.loads(session.get("session_data", {}))
+            session_metrics = session_data.get("session_metrics", {})
+            for field in token_metrics:
+                token_metrics[field] += session_metrics.get(field, 0)
+
+    model_metrics = []
+    for model, count in model_counts.items():
+        model_id, model_provider = model.split(":")
+        model_metrics.append({"model_id": model_id, "model_provider": model_provider, "count": count})
+
+    metrics["users_count"] = len(all_user_ids)
+    current_time = int(time.time())
+
+    return {
+        "id": str(uuid4()),
+        "date": date_to_process,
+        "completed": date_to_process < datetime.now(timezone.utc).date(),
+        "token_metrics": token_metrics,
+        "model_metrics": model_metrics,
+        "created_at": current_time,
+        "updated_at": current_time,
+        "aggregation_period": "daily",
+        **metrics,
+    }
+
+
+def fetch_all_sessions_data(
+    sessions: List[Dict[str, Any]], dates_to_process: list[date], start_timestamp: int
+) -> Optional[dict]:
+    """Return all session data for the given dates, for all session types.
+
+    Args:
+        dates_to_process (list[date]): The dates to fetch session data for.
+
+    Returns:
+        dict: A dictionary with dates as keys and session data as values, for all session types.
+
+    Example:
+    {
+        "2000-01-01": {
+            "agent": [<session1>, <session2>, ...],
+            "team": [...],
+            "workflow": [...],
+        }
+    }
+    """
+    if not dates_to_process:
+        return None
+
+    all_sessions_data: Dict[str, Dict[str, List[Dict[str, Any]]]] = {
+        date_to_process.isoformat(): {"agent": [], "team": [], "workflow": []} for date_to_process in dates_to_process
+    }
+
+    for session in sessions:
+        session_date = (
+            datetime.fromtimestamp(session.get("created_at", start_timestamp), tz=timezone.utc).date().isoformat()
+        )
+        if session_date in all_sessions_data:
+            all_sessions_data[session_date][session["session_type"]].append(session)
+
+    return all_sessions_data
+
+
+def get_dates_to_calculate_metrics_for(starting_date: date) -> list[date]:
+    """Return the list of dates to calculate metrics for.
+
+    Args:
+        starting_date (date): The starting date to calculate metrics for.
+
+    Returns:
+        list[date]: The list of dates to calculate metrics for.
+    """
+    today = datetime.now(timezone.utc).date()
+    days_diff = (today - starting_date).days + 1
+    if days_diff <= 0:
+        return []
+    return [starting_date + timedelta(days=x) for x in range(days_diff)]

agno/db/utils.py

@@ -0,0 +1,88 @@
+"""Logic shared across different database implementations"""
+
+import json
+from datetime import date, datetime
+from uuid import UUID
+
+from agno.db.base import SessionType
+from agno.models.message import Message
+from agno.models.metrics import Metrics
+
+
+class CustomJSONEncoder(json.JSONEncoder):
+    """Custom encoder to handle non JSON serializable types."""
+
+    def default(self, obj):
+        if isinstance(obj, UUID):
+            return str(obj)
+        elif isinstance(obj, (date, datetime)):
+            return obj.isoformat()
+        elif isinstance(obj, Message):
+            return obj.to_dict()
+        elif isinstance(obj, Metrics):
+            return obj.to_dict()
+
+        return super().default(obj)
+
+
+def serialize_session_json_fields(session: dict) -> dict:
+    """Serialize all JSON fields in the given Session dictionary.
+
+    Args:
+        data (dict): The dictionary to serialize JSON fields in.
+
+    Returns:
+        dict: The dictionary with JSON fields serialized.
+    """
+    if session.get("session_data") is not None:
+        session["session_data"] = json.dumps(session["session_data"])
+    if session.get("agent_data") is not None:
+        session["agent_data"] = json.dumps(session["agent_data"])
+    if session.get("team_data") is not None:
+        session["team_data"] = json.dumps(session["team_data"])
+    if session.get("workflow_data") is not None:
+        session["workflow_data"] = json.dumps(session["workflow_data"])
+    if session.get("metadata") is not None:
+        session["metadata"] = json.dumps(session["metadata"])
+    if session.get("chat_history") is not None:
+        session["chat_history"] = json.dumps(session["chat_history"])
+    if session.get("summary") is not None:
+        session["summary"] = json.dumps(session["summary"], cls=CustomJSONEncoder)
+    if session.get("runs") is not None:
+        session["runs"] = json.dumps(session["runs"], cls=CustomJSONEncoder)
+
+    return session
+
+
+def deserialize_session_json_fields(session: dict) -> dict:
+    """Deserialize all JSON fields in the given Session dictionary.
+
+    Args:
+        session (dict): The dictionary to deserialize.
+
+    Returns:
+        dict: The dictionary with JSON fields deserialized.
+    """
+    if session.get("agent_data") is not None:
+        session["agent_data"] = json.loads(session["agent_data"])
+    if session.get("team_data") is not None:
+        session["team_data"] = json.loads(session["team_data"])
+    if session.get("workflow_data") is not None:
+        session["workflow_data"] = json.loads(session["workflow_data"])
+    if session.get("metadata") is not None:
+        session["metadata"] = json.loads(session["metadata"])
+    if session.get("chat_history") is not None:
+        session["chat_history"] = json.loads(session["chat_history"])
+    if session.get("summary") is not None:
+        session["summary"] = json.loads(session["summary"])
+    if session.get("session_data") is not None and isinstance(session["session_data"], str):
+        session["session_data"] = json.loads(session["session_data"])
+    if session.get("runs") is not None:
+        if session["session_type"] == SessionType.AGENT.value:
+            session["runs"] = json.loads(session["runs"])
+        if session["session_type"] == SessionType.TEAM.value:
+            session["runs"] = json.loads(session["runs"])
+        if session["session_type"] == SessionType.WORKFLOW.value:
+            session["runs"] = json.loads(session["runs"])
+
+    return session

agno/eval/__init__.py

@@ -0,0 +1,14 @@
+from agno.eval.accuracy import AccuracyAgentResponse, AccuracyEval, AccuracyEvaluation, AccuracyResult
+from agno.eval.performance import PerformanceEval, PerformanceResult
+from agno.eval.reliability import ReliabilityEval, ReliabilityResult
+
+__all__ = [
+    "AccuracyAgentResponse",
+    "AccuracyEvaluation",
+    "AccuracyResult",
+    "AccuracyEval",
+    "PerformanceEval",
+    "PerformanceResult",
+    "ReliabilityEval",
+    "ReliabilityResult",
+]

agno/eval/accuracy.py

@@ -1,14 +1,15 @@
 from dataclasses import asdict, dataclass, field
 from os import getenv
 from textwrap import dedent
-from typing import TYPE_CHECKING, Callable, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union
 from uuid import uuid4
 
 from pydantic import BaseModel, Field
 
 from agno.agent import Agent
-from agno.api.schemas.evals import EvalType
-from agno.eval.utils import async_log_eval_run, log_eval_run, store_result_in_file
+from agno.db.base import BaseDb
+from agno.db.schemas.evals import EvalType
+from agno.eval.utils import async_log_eval, log_eval_run, store_result_in_file
 from agno.exceptions import EvalError
 from agno.models.base import Model
 from agno.team.team import Team
@@ -167,8 +168,13 @@ class AccuracyEval:
     file_path_to_save_results: Optional[str] = None
     # Enable debug logs
     debug_mode: bool = getenv("AGNO_DEBUG", "false").lower() == "true"
-    # Log the results to the Agno platform. On by default.
-    monitoring: bool = getenv("AGNO_MONITOR", "true").lower() == "true"
+    # The database to store Evaluation results
+    db: Optional[BaseDb] = None
+
+    # Telemetry settings
+    # telemetry=True logs minimal telemetry for analytics
+    # This helps us improve our Evals and provide better support
+    telemetry: bool = True
 
     def get_evaluator_agent(self) -> Agent:
         """Return the evaluator agent. If not provided, build it based on the evaluator fields and default instructions."""
@@ -235,7 +241,7 @@ You are an expert judge tasked with comparing the quality of an AI Agent’s out
 {additional_guidelines}{additional_context}
 Remember: You must only compare the agent_output to the expected_output. The expected_output is correct as it was provided by the user.
 """,
-            response_model=AccuracyAgentResponse,
+            output_schema=AccuracyAgentResponse,
             structured_outputs=True,
         )
 
@@ -344,9 +350,9 @@ Remember: You must only compare the agent_output to the expected_output. The exp
                 live_log.update(status)
 
                 if self.agent is not None:
-                    output = self.agent.run(message=eval_input).content
+                    output = self.agent.run(input=eval_input).content
                 elif self.team is not None:
-                    output = self.team.run(message=eval_input).content
+                    output = self.team.run(input=eval_input).content
 
                 if not output:
                     logger.error(f"Failed to generate a valid answer on iteration {i + 1}: {output}")
@@ -398,22 +404,31 @@ Remember: You must only compare the agent_output to the expected_output. The exp
         if self.print_summary or print_summary:
             self.result.print_summary(console)
 
-        # Log results to the Agno platform if requested
+        # Log results to the Agno DB if requested
         if self.agent is not None:
-            agent_id = self.agent.agent_id
+            agent_id = self.agent.id
             team_id = None
             model_id = self.agent.model.id if self.agent.model is not None else None
             model_provider = self.agent.model.provider if self.agent.model is not None else None
-            evaluated_entity_name = self.agent.name
+            evaluated_component_name = self.agent.name
         elif self.team is not None:
             agent_id = None
-            team_id = self.team.team_id
+            team_id = self.team.id
             model_id = self.team.model.id if self.team.model is not None else None
             model_provider = self.team.model.provider if self.team.model is not None else None
-            evaluated_entity_name = self.team.name
+            evaluated_component_name = self.team.name
+
+        if self.db:
+            log_eval_input = {
+                "additional_guidelines": self.additional_guidelines,
+                "additional_context": self.additional_context,
+                "num_iterations": self.num_iterations,
+                "expected_output": self.expected_output,
+                "input": self.input,
+            }
 
-        if self.monitoring:
             log_eval_run(
+                db=self.db,
                 run_id=self.eval_id,  # type: ignore
                 run_data=asdict(self.result),
                 eval_type=EvalType.ACCURACY,
@@ -422,7 +437,19 @@ Remember: You must only compare the agent_output to the expected_output. The exp
                 model_id=model_id,
                 model_provider=model_provider,
                 name=self.name if self.name is not None else None,
-                evaluated_entity_name=evaluated_entity_name,
+                evaluated_component_name=evaluated_component_name,
+                eval_input=log_eval_input,
+            )
+
+        if self.telemetry:
+            from agno.api.evals import EvalRunCreate, create_eval_run_telemetry
+
+            create_eval_run_telemetry(
+                eval_run=EvalRunCreate(
+                    run_id=self.eval_id,
+                    eval_type=EvalType.ACCURACY,
+                    data=self._get_telemetry_data(),
+                ),
             )
 
         logger.debug(f"*********** Evaluation {self.eval_id} Finished ***********")
@@ -464,10 +491,10 @@ Remember: You must only compare the agent_output to the expected_output. The exp
                 live_log.update(status)
 
                 if self.agent is not None:
-                    response = await self.agent.arun(message=eval_input)
+                    response = await self.agent.arun(input=eval_input)
                     output = response.content
                 elif self.team is not None:
-                    response = await self.team.arun(message=eval_input)
+                    response = await self.team.arun(input=eval_input)  # type: ignore
                     output = response.content
 
                 if not output:
@@ -520,19 +547,48 @@ Remember: You must only compare the agent_output to the expected_output. The exp
         if self.print_summary or print_summary:
             self.result.print_summary(console)
 
-        # Log results to the Agno platform if requested
-        if self.monitoring:
-            await async_log_eval_run(
+        if self.agent is not None:
+            agent_id = self.agent.id
+            team_id = None
+            model_id = self.agent.model.id if self.agent.model is not None else None
+            model_provider = self.agent.model.provider if self.agent.model is not None else None
+            evaluated_component_name = self.agent.name
+        elif self.team is not None:
+            agent_id = None
+            team_id = self.team.id
+            model_id = self.team.model.id if self.team.model is not None else None
+            model_provider = self.team.model.provider if self.team.model is not None else None
+            evaluated_component_name = self.team.name
+
+        # Log results to the Agno DB if requested
+        if self.db:
+            log_eval_input = {
+                "additional_guidelines": self.additional_guidelines,
+                "additional_context": self.additional_context,
+                "num_iterations": self.num_iterations,
+                "expected_output": self.expected_output,
+                "input": self.input,
+            }
+            await async_log_eval(
+                db=self.db,
                 run_id=self.eval_id,  # type: ignore
                 run_data=asdict(self.result),
                 eval_type=EvalType.ACCURACY,
-                agent_id=self.agent.agent_id if self.agent is not None else None,
-                model_id=self.agent.model.id if self.agent is not None and self.agent.model is not None else None,
-                model_provider=self.agent.model.provider
-                if self.agent is not None and self.agent.model is not None
-                else None,
+                agent_id=agent_id,
+                model_id=model_id,
+                model_provider=model_provider,
                 name=self.name if self.name is not None else None,
-                evaluated_entity_name=self.agent.name if self.agent is not None else None,
+                evaluated_component_name=evaluated_component_name,
+                team_id=team_id,
+                workflow_id=None,
+                eval_input=log_eval_input,
+            )
+
+        if self.telemetry:
+            from agno.api.evals import EvalRunCreate, async_create_eval_run_telemetry
+
+            await async_create_eval_run_telemetry(
+                eval_run=EvalRunCreate(run_id=self.eval_id, eval_type=EvalType.ACCURACY),
             )
 
         logger.debug(f"*********** Evaluation {self.eval_id} Finished ***********")
@@ -596,28 +652,37 @@ Remember: You must only compare the agent_output to the expected_output. The exp
                     eval_id=self.eval_id,
                     result=self.result,
                 )
-        # Log results to the Agno platform if requested
-        if self.monitoring:
+        # Log results to the Agno DB if requested
+        if self.db:
             if self.agent is not None:
-                agent_id = self.agent.agent_id
+                agent_id = self.agent.id
                 team_id = None
                 model_id = self.agent.model.id if self.agent.model is not None else None
                 model_provider = self.agent.model.provider if self.agent.model is not None else None
-                evaluated_entity_name = self.agent.name
+                evaluated_component_name = self.agent.name
             elif self.team is not None:
                 agent_id = None
-                team_id = self.team.team_id
+                team_id = self.team.id
                 model_id = self.team.model.id if self.team.model is not None else None
                 model_provider = self.team.model.provider if self.team.model is not None else None
-                evaluated_entity_name = self.team.name
+                evaluated_component_name = self.team.name
             else:
                 agent_id = None
                 team_id = None
                 model_id = None
                 model_provider = None
-                evaluated_entity_name = None
+                evaluated_component_name = None
+
+            log_eval_input = {
+                "additional_guidelines": self.additional_guidelines,
+                "additional_context": self.additional_context,
+                "num_iterations": self.num_iterations,
+                "expected_output": self.expected_output,
+                "input": self.input,
+            }
 
             log_eval_run(
+                db=self.db,
                 run_id=self.eval_id,  # type: ignore
                 run_data=asdict(self.result),
                 eval_type=EvalType.ACCURACY,
@@ -626,7 +691,20 @@ Remember: You must only compare the agent_output to the expected_output. The exp
                 team_id=team_id,
                 model_id=model_id,
                 model_provider=model_provider,
-                evaluated_entity_name=evaluated_entity_name,
+                evaluated_component_name=evaluated_component_name,
+                workflow_id=None,
+                eval_input=log_eval_input,
+            )
+
+        if self.telemetry:
+            from agno.api.evals import EvalRunCreate, create_eval_run_telemetry
+
+            create_eval_run_telemetry(
+                eval_run=EvalRunCreate(
+                    run_id=self.eval_id,
+                    eval_type=EvalType.ACCURACY,
+                    data=self._get_telemetry_data(),
+                ),
             )
 
         logger.debug(f"*********** Evaluation End: {self.eval_id} ***********")
@@ -690,22 +768,31 @@ Remember: You must only compare the agent_output to the expected_output. The exp
                     eval_id=self.eval_id,
                     result=self.result,
                 )
-        # Log results to the Agno platform if requested
-        if self.monitoring:
+        # Log results to the Agno DB if requested
+        if self.db:
             if self.agent is not None:
-                agent_id = self.agent.agent_id
+                agent_id = self.agent.id
                 team_id = None
                 model_id = self.agent.model.id if self.agent.model is not None else None
                 model_provider = self.agent.model.provider if self.agent.model is not None else None
-                evaluated_entity_name = self.agent.name
+                evaluated_component_name = self.agent.name
             elif self.team is not None:
                 agent_id = None
-                team_id = self.team.team_id
+                team_id = self.team.id
                 model_id = self.team.model.id if self.team.model is not None else None
                 model_provider = self.team.model.provider if self.team.model is not None else None
-                evaluated_entity_name = self.team.name
-
-            await async_log_eval_run(
+                evaluated_component_name = self.team.name
+
+            log_eval_input = {
+                "additional_guidelines": self.additional_guidelines,
+                "additional_context": self.additional_context,
+                "num_iterations": self.num_iterations,
+                "expected_output": self.expected_output,
+                "input": self.input,
+            }
+
+            await async_log_eval(
+                db=self.db,
                 run_id=self.eval_id,  # type: ignore
                 run_data=asdict(self.result),
                 eval_type=EvalType.ACCURACY,
@@ -714,8 +801,20 @@ Remember: You must only compare the agent_output to the expected_output. The exp
                 team_id=team_id,
                 model_id=model_id,
                 model_provider=model_provider,
-                evaluated_entity_name=evaluated_entity_name,
+                evaluated_component_name=evaluated_component_name,
+                workflow_id=None,
+                eval_input=log_eval_input,
             )
 
         logger.debug(f"*********** Evaluation End: {self.eval_id} ***********")
         return self.result
+
+    def _get_telemetry_data(self) -> Dict[str, Any]:
+        """Get the telemetry data for the evaluation"""
+        return {
+            "agent_id": self.agent.id if self.agent else None,
+            "team_id": self.team.id if self.team else None,
+            "model_id": self.agent.model.id if self.agent and self.agent.model else None,
+            "model_provider": self.agent.model.provider if self.agent and self.agent.model else None,
+            "num_iterations": self.num_iterations,
+        }