agno 2.3.19__py3-none-any.whl → 2.3.21__py3-none-any.whl

agno/db/dynamo/utils.py

@@ -8,6 +8,7 @@ from agno.db.base import SessionType
 from agno.db.schemas.culture import CulturalKnowledge
 from agno.db.schemas.evals import EvalRunRecord
 from agno.db.schemas.knowledge import KnowledgeRow
+from agno.db.utils import get_sort_value
 from agno.session import Session
 from agno.utils.log import log_debug, log_error, log_info
 
@@ -174,13 +175,35 @@ def apply_pagination(
 def apply_sorting(
     items: List[Dict[str, Any]], sort_by: Optional[str] = None, sort_order: Optional[str] = None
 ) -> List[Dict[str, Any]]:
-    """Apply sorting to a list of items."""
+    """Apply sorting to a list of items.
+
+    Args:
+        items: The list of dictionaries to sort
+        sort_by: The field to sort by (defaults to 'created_at')
+        sort_order: The sort order ('asc' or 'desc')
+
+    Returns:
+        The sorted list
+
+    Note:
+        If sorting by "updated_at", will fallback to "created_at" in case of None.
+    """
+    if not items:
+        return items
+
     if sort_by is None:
         sort_by = "created_at"
 
-    reverse = sort_order == "desc"
+    is_descending = sort_order == "desc"
+
+    # Sort using the helper function that handles updated_at -> created_at fallback
+    sorted_records = sorted(
+        items,
+        key=lambda x: (get_sort_value(x, sort_by) is None, get_sort_value(x, sort_by)),
+        reverse=is_descending,
+    )
 
-    return sorted(items, key=lambda x: x.get(sort_by, ""), reverse=reverse)
+    return sorted_records
 
 
 # -- Session utils --

agno/db/firestore/utils.py

@@ -8,6 +8,7 @@ from uuid import uuid4
 
 from agno.db.firestore.schemas import get_collection_indexes
 from agno.db.schemas.culture import CulturalKnowledge
+from agno.db.utils import get_sort_value
 from agno.utils.log import log_debug, log_error, log_info, log_warning
 
 try:
@@ -126,19 +127,33 @@ def apply_pagination(query, limit: Optional[int] = None, page: Optional[int] = N
 def apply_sorting_to_records(
     records: List[Dict[str, Any]], sort_by: Optional[str] = None, sort_order: Optional[str] = None
 ) -> List[Dict[str, Any]]:
-    """Apply sorting to in-memory records (for cases where Firestore query sorting isn't possible)."""
-    if sort_by is None:
-        return records
+    """Apply sorting to in-memory records (for cases where Firestore query sorting isn't possible).
+
+    Args:
+        records: The list of dictionaries to sort
+        sort_by: The field to sort by
+        sort_order: The sort order ('asc' or 'desc')
 
-    def get_sort_key(record):
-        value = record.get(sort_by, 0)
-        if value is None:
-            return 0 if records and isinstance(records[0].get(sort_by, 0), (int, float)) else ""
-        return value
+    Returns:
+        The sorted list
+
+    Note:
+        If sorting by "updated_at", will fallback to "created_at" in case of None.
+    """
+    if sort_by is None or not records:
+        return records
 
     try:
-        is_reverse = sort_order == "desc"
-        return sorted(records, key=get_sort_key, reverse=is_reverse)
+        is_descending = sort_order == "desc"
+
+        # Sort using the helper function that handles updated_at -> created_at fallback
+        sorted_records = sorted(
+            records,
+            key=lambda x: (get_sort_value(x, sort_by) is None, get_sort_value(x, sort_by)),
+            reverse=is_descending,
+        )
+
+        return sorted_records
     except Exception as e:
         log_warning(f"Error sorting Firestore records: {e}")
         return records

agno/db/gcs_json/utils.py

@@ -6,6 +6,7 @@ from typing import Any, Dict, List, Optional
 from uuid import uuid4
 
 from agno.db.schemas.culture import CulturalKnowledge
+from agno.db.utils import get_sort_value
 from agno.utils.log import log_debug
 
 
@@ -21,6 +22,9 @@ def apply_sorting(
 
     Returns:
         The sorted list
+
+    Note:
+        If sorting by "updated_at", will fallback to "created_at" in case of None.
     """
     if sort_by is None or not data:
         return data
@@ -31,8 +35,16 @@ def apply_sorting(
         return data
 
     try:
-        reverse_order = sort_order != "asc" if sort_order else True
-        return sorted(data, key=lambda x: x.get(sort_by, 0), reverse=reverse_order)
+        is_descending = sort_order != "asc" if sort_order else True
+
+        # Sort using the helper function that handles updated_at -> created_at fallback
+        sorted_records = sorted(
+            data,
+            key=lambda x: (get_sort_value(x, sort_by) is None, get_sort_value(x, sort_by)),
+            reverse=is_descending,
+        )
+
+        return sorted_records
     except Exception as e:
         log_debug(f"Error sorting data by '{sort_by}': {e}")
         return data

agno/db/in_memory/utils.py

@@ -6,6 +6,7 @@ from typing import Any, Dict, List, Optional
 from uuid import uuid4
 
 from agno.db.schemas.culture import CulturalKnowledge
+from agno.db.utils import get_sort_value
 from agno.utils.log import log_debug
 
 
@@ -21,6 +22,9 @@ def apply_sorting(
 
     Returns:
         The sorted list
+
+    Note:
+        If sorting by "updated_at", will fallback to "created_at" in case of None.
     """
     if sort_by is None or not data:
         return data
@@ -31,8 +35,16 @@ def apply_sorting(
         return data
 
     try:
-        reverse_order = sort_order != "asc" if sort_order else True
-        return sorted(data, key=lambda x: x.get(sort_by, 0), reverse=reverse_order)
+        is_descending = sort_order != "asc" if sort_order else True
+
+        # Sort using the helper function that handles updated_at -> created_at fallback
+        sorted_records = sorted(
+            data,
+            key=lambda x: (get_sort_value(x, sort_by) is None, get_sort_value(x, sort_by)),
+            reverse=is_descending,
+        )
+
+        return sorted_records
     except Exception as e:
         log_debug(f"Error sorting data by '{sort_by}': {e}")
         return data

agno/db/json/utils.py

@@ -6,6 +6,7 @@ from typing import Any, Dict, List, Optional
 from uuid import uuid4
 
 from agno.db.schemas.culture import CulturalKnowledge
+from agno.db.utils import get_sort_value
 from agno.utils.log import log_debug
 
 
@@ -21,6 +22,9 @@ def apply_sorting(
 
     Returns:
         The sorted list
+
+    Note:
+        If sorting by "updated_at", will fallback to "created_at" in case of None.
     """
     if sort_by is None or not data:
         return data
@@ -31,8 +35,16 @@ def apply_sorting(
         return data
 
     try:
-        reverse_order = sort_order != "asc" if sort_order else True
-        return sorted(data, key=lambda x: x.get(sort_by, 0), reverse=reverse_order)
+        is_descending = sort_order != "asc" if sort_order else True
+
+        # Sort using the helper function that handles updated_at -> created_at fallback
+        sorted_records = sorted(
+            data,
+            key=lambda x: (get_sort_value(x, sort_by) is None, get_sort_value(x, sort_by)),
+            reverse=is_descending,
+        )
+
+        return sorted_records
     except Exception as e:
         log_debug(f"Error sorting data by '{sort_by}': {e}")
         return data

agno/db/mysql/utils.py

@@ -10,7 +10,7 @@ from agno.db.schemas.culture import CulturalKnowledge
 from agno.utils.log import log_debug, log_error, log_warning
 
 try:
-    from sqlalchemy import Engine, Table
+    from sqlalchemy import Engine, Table, func
     from sqlalchemy.dialects import mysql
     from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
     from sqlalchemy.inspection import inspect
@@ -32,6 +32,11 @@ def apply_sorting(stmt, table: Table, sort_by: Optional[str] = None, sort_order:
 
     Returns:
         The modified statement with sorting applied
+
+    Note:
+        For 'updated_at' sorting, uses COALESCE(updated_at, created_at) to fall back
+        to created_at when updated_at is NULL. This ensures pre-2.0 records (which may
+        have NULL updated_at) are sorted correctly by their creation time.
     """
     if sort_by is None:
         return stmt
@@ -40,8 +45,13 @@ def apply_sorting(stmt, table: Table, sort_by: Optional[str] = None, sort_order:
         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)
+    # For updated_at, use COALESCE to fall back to created_at if updated_at is NULL
+    # This handles pre-2.0 records that may have NULL updated_at values
+    if sort_by == "updated_at" and hasattr(table.c, "created_at"):
+        sort_column = func.coalesce(table.c.updated_at, table.c.created_at)
+    else:
+        sort_column = getattr(table.c, sort_by)
+
     if sort_order and sort_order == "asc":
         return stmt.order_by(sort_column.asc())
     else:

agno/db/postgres/utils.py

@@ -13,7 +13,7 @@ from agno.db.schemas.culture import CulturalKnowledge
 from agno.utils.log import log_debug, log_error, log_warning
 
 try:
-    from sqlalchemy import Table
+    from sqlalchemy import Table, func
     from sqlalchemy.dialects import postgresql
     from sqlalchemy.inspection import inspect
     from sqlalchemy.orm import Session
@@ -34,6 +34,11 @@ def apply_sorting(stmt, table: Table, sort_by: Optional[str] = None, sort_order:
 
     Returns:
         The modified statement with sorting applied
+
+    Note:
+        For 'updated_at' sorting, uses COALESCE(updated_at, created_at) to fall back
+        to created_at when updated_at is NULL. This ensures pre-2.0 records (which may
+        have NULL updated_at) are sorted correctly by their creation time.
     """
     if sort_by is None:
         return stmt
@@ -42,8 +47,13 @@ def apply_sorting(stmt, table: Table, sort_by: Optional[str] = None, sort_order:
         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)
+    # For updated_at, use COALESCE to fall back to created_at if updated_at is NULL
+    # This handles pre-2.0 records that may have NULL updated_at values
+    if sort_by == "updated_at" and hasattr(table.c, "created_at"):
+        sort_column = func.coalesce(table.c.updated_at, table.c.created_at)
+    else:
+        sort_column = getattr(table.c, sort_by)
+
     if sort_order and sort_order == "asc":
         return stmt.order_by(sort_column.asc())
     else:

agno/db/redis/utils.py

@@ -7,6 +7,7 @@ from typing import Any, Dict, List, Optional, Union
 from uuid import UUID
 
 from agno.db.schemas.culture import CulturalKnowledge
+from agno.db.utils import get_sort_value
 from agno.utils.log import log_warning
 
 try:
@@ -80,21 +81,36 @@ def get_all_keys_for_table(redis_client: Union[Redis, RedisCluster], prefix: str
 def apply_sorting(
     records: List[Dict[str, Any]], sort_by: Optional[str] = None, sort_order: Optional[str] = None
 ) -> List[Dict[str, Any]]:
-    if sort_by is None:
-        return records
+    """Apply sorting to the given records list.
+
+    Args:
+        records: The list of dictionaries to sort
+        sort_by: The field to sort by
+        sort_order: The sort order ('asc' or 'desc')
+
+    Returns:
+        The sorted list
 
-    def get_sort_key(record):
-        value = record.get(sort_by, 0)
-        if value is None:
-            return 0 if isinstance(records[0].get(sort_by, 0), (int, float)) else ""
-        return value
+    Note:
+        If sorting by "updated_at", will fallback to "created_at" in case of None.
+    """
+    if sort_by is None or not records:
+        return records
 
     try:
-        is_reverse = sort_order == "desc"
-        return sorted(records, key=get_sort_key, reverse=is_reverse)
+        is_descending = sort_order == "desc"
+
+        # Sort using the helper function that handles updated_at -> created_at fallback
+        sorted_records = sorted(
+            records,
+            key=lambda x: (get_sort_value(x, sort_by) is None, get_sort_value(x, sort_by)),
+            reverse=is_descending,
+        )
+
+        return sorted_records
 
     except Exception as e:
-        log_warning(f"Error sorting Redisrecords: {e}")
+        log_warning(f"Error sorting Redis records: {e}")
         return records
 
 

agno/db/schemas/memory.py

@@ -1,8 +1,8 @@
 from dataclasses import dataclass
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import Any, Dict, List, Optional
 
-from agno.utils.dttm import now_epoch_s
+from agno.utils.dttm import now_epoch_s, to_epoch_s
 
 
 @dataclass
@@ -22,17 +22,20 @@ class UserMemory:
     team_id: Optional[str] = None
 
     def __post_init__(self) -> None:
-        """Automatically set created_at if not provided."""
-        if self.created_at is None:
-            self.created_at = now_epoch_s()
+        """Automatically set/normalize created_at and updated_at."""
+        self.created_at = now_epoch_s() if self.created_at is None else to_epoch_s(self.created_at)
+        if self.updated_at is not None:
+            self.updated_at = to_epoch_s(self.updated_at)
 
     def to_dict(self) -> Dict[str, Any]:
+        created_at = datetime.fromtimestamp(self.created_at).isoformat() if self.created_at is not None else None
+        updated_at = datetime.fromtimestamp(self.updated_at).isoformat() if self.updated_at is not None else created_at
         _dict = {
             "memory_id": self.memory_id,
             "memory": self.memory,
             "topics": self.topics,
-            "created_at": datetime.fromtimestamp(self.created_at).isoformat() if self.created_at else None,
-            "updated_at": datetime.fromtimestamp(self.updated_at).isoformat() if self.updated_at else None,
+            "created_at": created_at,
+            "updated_at": updated_at,
             "input": self.input,
             "user_id": self.user_id,
             "agent_id": self.agent_id,
@@ -45,17 +48,10 @@ class UserMemory:
     def from_dict(cls, data: Dict[str, Any]) -> "UserMemory":
         data = dict(data)
 
-        if created_at := data.get("created_at"):
-            if isinstance(created_at, (int, float)):
-                data["created_at"] = datetime.fromtimestamp(created_at, tz=timezone.utc)
-            else:
-                data["created_at"] = datetime.fromisoformat(created_at)
-
-        # Convert updated_at to datetime
-        if updated_at := data.get("updated_at"):
-            if isinstance(updated_at, (int, float)):
-                data["updated_at"] = datetime.fromtimestamp(updated_at, tz=timezone.utc)
-            else:
-                data["updated_at"] = datetime.fromisoformat(updated_at)
+        # Preserve 0 and None explicitly; only process if key exists
+        if "created_at" in data and data["created_at"] is not None:
+            data["created_at"] = to_epoch_s(data["created_at"])
+        if "updated_at" in data and data["updated_at"] is not None:
+            data["updated_at"] = to_epoch_s(data["updated_at"])
 
         return cls(**data)

agno/db/singlestore/utils.py

@@ -12,7 +12,7 @@ from agno.db.singlestore.schemas import get_table_schema_definition
 from agno.utils.log import log_debug, log_error, log_warning
 
 try:
-    from sqlalchemy import Table
+    from sqlalchemy import Table, func
     from sqlalchemy.inspection import inspect
     from sqlalchemy.orm import Session
     from sqlalchemy.sql.expression import text
@@ -32,6 +32,11 @@ def apply_sorting(stmt, table: Table, sort_by: Optional[str] = None, sort_order:
 
     Returns:
         The modified statement with sorting applied
+
+    Note:
+        For 'updated_at' sorting, uses COALESCE(updated_at, created_at) to fall back
+        to created_at when updated_at is NULL. This ensures pre-2.0 records (which may
+        have NULL updated_at) are sorted correctly by their creation time.
     """
     if sort_by is None:
         return stmt
@@ -40,8 +45,13 @@ def apply_sorting(stmt, table: Table, sort_by: Optional[str] = None, sort_order:
         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)
+    # For updated_at, use COALESCE to fall back to created_at if updated_at is NULL
+    # This handles pre-2.0 records that may have NULL updated_at values
+    if sort_by == "updated_at" and hasattr(table.c, "created_at"):
+        sort_column = func.coalesce(table.c.updated_at, table.c.created_at)
+    else:
+        sort_column = getattr(table.c, sort_by)
+
     if sort_order and sort_order == "asc":
         return stmt.order_by(sort_column.asc())
     else:

agno/db/sqlite/utils.py

@@ -11,7 +11,7 @@ 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 import Table, func
     from sqlalchemy.dialects import sqlite
     from sqlalchemy.engine import Engine
     from sqlalchemy.inspection import inspect
@@ -26,13 +26,20 @@ except ImportError:
 
 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
+
+    Note:
+        For 'updated_at' sorting, uses COALESCE(updated_at, created_at) to fall back
+        to created_at when updated_at is NULL. This ensures pre-2.0 records (which may
+        have NULL updated_at) are sorted correctly by their creation time.
     """
     if sort_by is None:
         return stmt
@@ -40,8 +47,13 @@ def apply_sorting(stmt, table: Table, sort_by: Optional[str] = None, sort_order:
         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)
+    # For updated_at, use COALESCE to fall back to created_at if updated_at is NULL
+    # This handles pre-2.0 records that may have NULL updated_at values
+    if sort_by == "updated_at" and hasattr(table.c, "created_at"):
+        sort_column = func.coalesce(table.c.updated_at, table.c.created_at)
+    else:
+        sort_column = getattr(table.c, sort_by)
+
     if sort_order and sort_order == "asc":
         return stmt.order_by(sort_column.asc())
     else:

agno/db/utils.py

@@ -2,12 +2,34 @@
 
 import json
 from datetime import date, datetime
+from typing import Any, Dict
 from uuid import UUID
 
 from agno.models.message import Message
 from agno.models.metrics import Metrics
 
 
+def get_sort_value(record: Dict[str, Any], sort_by: str) -> Any:
+    """Get the sort value for a record, with fallback to created_at for updated_at.
+
+    When sorting by 'updated_at', this function falls back to 'created_at' if
+    'updated_at' is None. This ensures pre-2.0 records (which may have NULL
+    updated_at values) are sorted correctly by their creation time.
+
+    Args:
+        record: The record dictionary to get the sort value from
+        sort_by: The field to sort by
+
+    Returns:
+        The value to use for sorting
+    """
+    value = record.get(sort_by)
+    # For updated_at, fall back to created_at if updated_at is None
+    if value is None and sort_by == "updated_at":
+        value = record.get("created_at")
+    return value
+
+
 class CustomJSONEncoder(json.JSONEncoder):
     """Custom encoder to handle non JSON serializable types."""
 

agno/eval/agent_as_judge.py

@@ -518,8 +518,11 @@ class AgentAsJudgeEval(BaseEval):
         if self.print_summary or print_summary:
             result.print_summary(console)
 
+        # evaluator model info
+        model_id = self.model.id if self.model is not None else None
+        model_provider = self.model.provider if self.model is not None else None
         # Log to DB
-        self._log_eval_to_db(run_id=run_id, result=result)
+        self._log_eval_to_db(run_id=run_id, result=result, model_id=model_id, model_provider=model_provider)
 
         if self.telemetry:
             from agno.api.evals import EvalRunCreate, create_eval_run_telemetry
@@ -613,8 +616,11 @@ class AgentAsJudgeEval(BaseEval):
         if self.print_summary or print_summary:
             result.print_summary(console)
 
+        # evaluator model info
+        model_id = self.model.id if self.model is not None else None
+        model_provider = self.model.provider if self.model is not None else None
         # Log to DB
-        await self._async_log_eval_to_db(run_id=run_id, result=result)
+        await self._async_log_eval_to_db(run_id=run_id, result=result, model_id=model_id, model_provider=model_provider)
 
         if self.telemetry:
             from agno.api.evals import EvalRunCreate, async_create_eval_run_telemetry
@@ -681,8 +687,11 @@ class AgentAsJudgeEval(BaseEval):
         if self.print_summary or print_summary:
             result.print_summary(console)
 
+        # evaluator model info
+        model_id = self.model.id if self.model is not None else None
+        model_provider = self.model.provider if self.model is not None else None
         # Log to DB
-        self._log_eval_to_db(run_id=run_id, result=result)
+        self._log_eval_to_db(run_id=run_id, result=result, model_id=model_id, model_provider=model_provider)
 
         if self.telemetry:
             from agno.api.evals import EvalRunCreate, create_eval_run_telemetry
@@ -748,8 +757,11 @@ class AgentAsJudgeEval(BaseEval):
         if self.print_summary or print_summary:
             result.print_summary(console)
 
+        # evaluator model info
+        model_id = self.model.id if self.model is not None else None
+        model_provider = self.model.provider if self.model is not None else None
         # Log to DB
-        await self._async_log_eval_to_db(run_id=run_id, result=result)
+        await self._async_log_eval_to_db(run_id=run_id, result=result, model_id=model_id, model_provider=model_provider)
 
         if self.telemetry:
             from agno.api.evals import EvalRunCreate, async_create_eval_run_telemetry
@@ -801,15 +813,14 @@ class AgentAsJudgeEval(BaseEval):
         if isinstance(run_output, RunOutput):
             agent_id = run_output.agent_id
             team_id = None
-            model_id = run_output.model
-            model_provider = run_output.model_provider
         elif isinstance(run_output, TeamRunOutput):
             agent_id = None
             team_id = run_output.team_id
-            model_id = run_output.model
-            model_provider = run_output.model_provider
 
-        # Log to DB if we have a valid result (use run_id from result)
+        # evaluator model info
+        model_id = self.model.id if self.model is not None else None
+        model_provider = self.model.provider if self.model is not None else None
+        # Log to DB if we have a valid result
         if result:
             self._log_eval_to_db(
                 run_id=result.run_id,
@@ -841,15 +852,14 @@ class AgentAsJudgeEval(BaseEval):
         if isinstance(run_output, RunOutput):
             agent_id = run_output.agent_id
             team_id = None
-            model_id = run_output.model
-            model_provider = run_output.model_provider
         elif isinstance(run_output, TeamRunOutput):
             agent_id = None
             team_id = run_output.team_id
-            model_id = run_output.model
-            model_provider = run_output.model_provider
 
-        # Log to DB if we have a valid result (use run_id from result)
+        # evaluator model info
+        model_id = self.model.id if self.model is not None else None
+        model_provider = self.model.provider if self.model is not None else None
+        # Log to DB if we have a valid result
         if result:
             await self._async_log_eval_to_db(
                 run_id=result.run_id,

agno/knowledge/embedder/mistral.py

@@ -37,7 +37,7 @@ class MistralEmbedder(Embedder):
             "api_key": self.api_key,
             "endpoint": self.endpoint,
             "max_retries": self.max_retries,
-            "timeout": self.timeout,
+            "timeout_ms": self.timeout * 1000 if self.timeout else None,
         }
         _client_params = {k: v for k, v in _client_params.items() if v is not None}
 

agno/models/litellm/chat.py

@@ -307,6 +307,9 @@ class LiteLLM(Model):
         if response_message.content is not None:
             model_response.content = response_message.content
 
+        if hasattr(response_message, "reasoning_content") and response_message.reasoning_content is not None:
+            model_response.reasoning_content = response_message.reasoning_content
+
         if hasattr(response_message, "tool_calls") and response_message.tool_calls:
             model_response.tool_calls = []
             for tool_call in response_message.tool_calls:
@@ -334,6 +337,9 @@ class LiteLLM(Model):
                 if hasattr(choice_delta, "content") and choice_delta.content is not None:
                     model_response.content = choice_delta.content
 
+                if hasattr(choice_delta, "reasoning_content") and choice_delta.reasoning_content is not None:
+                    model_response.reasoning_content = choice_delta.reasoning_content
+
                 if hasattr(choice_delta, "tool_calls") and choice_delta.tool_calls:
                     processed_tool_calls = []
                     for tool_call in choice_delta.tool_calls:

agno/os/routers/evals/evals.py

@@ -144,15 +144,6 @@ def attach_routes(
                 headers=headers,
             )
 
-        # TODO: Delete me:
-        # Filtering out agent-as-judge by default for now,
-        # as they are not supported yet in the AgentOS UI.
-        eval_types = eval_types or [
-            EvalType.ACCURACY,
-            EvalType.PERFORMANCE,
-            EvalType.RELIABILITY,
-        ]
-
         if isinstance(db, AsyncBaseDb):
             db = cast(AsyncBaseDb, db)
             eval_runs, total_count = await db.get_eval_runs(