agno 2.3.26__py3-none-any.whl → 2.4.1__py3-none-any.whl

agno/os/routers/knowledge/schemas.py

@@ -170,9 +170,21 @@ class VectorSearchRequestSchema(BaseModel):
     )
 
 
+class RemoteContentSourceSchema(BaseModel):
+    """Schema for remote content source configuration."""
+
+    id: str = Field(..., description="Unique identifier for the content source")
+    name: str = Field(..., description="Display name for the content source")
+    type: str = Field(..., description="Type of content source (s3, gcs, sharepoint, github)")
+    metadata: Optional[Dict[str, Any]] = Field(None, description="Custom metadata for the content source")
+
+
 class ConfigResponseSchema(BaseModel):
     readers: Optional[Dict[str, ReaderSchema]] = Field(None, description="Available content readers")
     readersForType: Optional[Dict[str, List[str]]] = Field(None, description="Mapping of content types to reader IDs")
     chunkers: Optional[Dict[str, ChunkerSchema]] = Field(None, description="Available chunking strategies")
     filters: Optional[List[str]] = Field(None, description="Available filter tags")
     vector_dbs: Optional[List[VectorDbSchema]] = Field(None, description="Configured vector databases")
+    remote_content_sources: Optional[List[RemoteContentSourceSchema]] = Field(
+        None, description="Configured remote content sources (S3, GCS, SharePoint, GitHub)"
+    )

agno/os/routers/memory/schemas.py

@@ -1,9 +1,11 @@
 import json
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel, Field
 
+from agno.os.utils import to_utc_datetime
+
 
 class DeleteMemoriesRequest(BaseModel):
     memory_ids: List[str] = Field(..., description="List of memory IDs to delete", min_length=1)
@@ -71,7 +73,7 @@ class UserStatsSchema(BaseModel):
         return cls(
             user_id=str(user_stats_dict["user_id"]),
             total_memories=user_stats_dict["total_memories"],
-            last_memory_updated_at=datetime.fromtimestamp(updated_at, tz=timezone.utc) if updated_at else None,
+            last_memory_updated_at=to_utc_datetime(updated_at),
         )
 
 

agno/os/routers/metrics/metrics.py

@@ -1,5 +1,5 @@
 import logging
-from datetime import date, datetime, timezone
+from datetime import date
 from typing import List, Optional, Union, cast
 
 from fastapi import Depends, HTTPException, Query, Request
@@ -16,7 +16,7 @@ from agno.os.schema import (
     ValidationErrorResponse,
 )
 from agno.os.settings import AgnoAPISettings
-from agno.os.utils import get_db
+from agno.os.utils import get_db, to_utc_datetime
 from agno.remote.base import RemoteDb
 
 logger = logging.getLogger(__name__)
@@ -79,9 +79,9 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
                                         "reasoning_tokens": 0,
                                     },
                                     "model_metrics": [{"model_id": "gpt-4o", "model_provider": "OpenAI", "count": 5}],
-                                    "date": "2025-07-31T00:00:00",
-                                    "created_at": 1753993132,
-                                    "updated_at": 1753993741,
+                                    "date": "2025-07-31T00:00:00Z",
+                                    "created_at": "2025-07-31T12:38:52Z",
+                                    "updated_at": "2025-07-31T12:49:01Z",
                                 }
                             ]
                         }
@@ -121,9 +121,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
 
             return MetricsResponse(
                 metrics=[DayAggregatedMetrics.from_dict(metric) for metric in metrics],
-                updated_at=datetime.fromtimestamp(latest_updated_at, tz=timezone.utc)
-                if latest_updated_at is not None
-                else None,
+                updated_at=to_utc_datetime(latest_updated_at),
             )
 
         except Exception as e:
@@ -167,9 +165,9 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
                                     "reasoning_tokens": 0,
                                 },
                                 "model_metrics": [{"model_id": "gpt-4o", "model_provider": "OpenAI", "count": 2}],
-                                "date": "2025-08-12T00:00:00",
-                                "created_at": 1755016907,
-                                "updated_at": 1755016907,
+                                "date": "2025-08-12T00:00:00Z",
+                                "created_at": "2025-08-12T08:01:47Z",
+                                "updated_at": "2025-08-12T08:01:47Z",
                             }
                         ]
                     }

agno/os/routers/metrics/schemas.py

@@ -1,8 +1,10 @@
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel, Field
 
+from agno.os.utils import to_utc_datetime
+
 
 class DayAggregatedMetrics(BaseModel):
     """Aggregated metrics for a given day"""
@@ -20,22 +22,24 @@ class DayAggregatedMetrics(BaseModel):
     model_metrics: List[Dict[str, Any]] = Field(..., description="Metrics grouped by model (model_id, provider, count)")
 
     date: datetime = Field(..., description="Date for which these metrics are aggregated")
-    created_at: int = Field(..., description="Unix timestamp when metrics were created", ge=0)
-    updated_at: int = Field(..., description="Unix timestamp when metrics were last updated", ge=0)
+    created_at: datetime = Field(..., description="Timestamp when metrics were created")
+    updated_at: datetime = Field(..., description="Timestamp when metrics were last updated")
 
     @classmethod
     def from_dict(cls, metrics_dict: Dict[str, Any]) -> "DayAggregatedMetrics":
+        created_at = to_utc_datetime(metrics_dict.get("created_at")) or datetime.now(timezone.utc)
+        updated_at = to_utc_datetime(metrics_dict.get("updated_at", created_at)) or created_at
         return cls(
             agent_runs_count=metrics_dict.get("agent_runs_count", 0),
             agent_sessions_count=metrics_dict.get("agent_sessions_count", 0),
-            created_at=metrics_dict.get("created_at", 0),
-            date=metrics_dict.get("date", datetime.now()),
+            date=metrics_dict.get("date", datetime.now(timezone.utc)),
             id=metrics_dict.get("id", ""),
             model_metrics=metrics_dict.get("model_metrics", {}),
             team_runs_count=metrics_dict.get("team_runs_count", 0),
             team_sessions_count=metrics_dict.get("team_sessions_count", 0),
             token_metrics=metrics_dict.get("token_metrics", {}),
-            updated_at=metrics_dict.get("updated_at", metrics_dict.get("created_at", 0)),
+            created_at=created_at,
+            updated_at=updated_at,
             users_count=metrics_dict.get("users_count", 0),
             workflow_runs_count=metrics_dict.get("workflow_runs_count", 0),
             workflow_sessions_count=metrics_dict.get("workflow_sessions_count", 0),

agno/os/routers/registry/__init__.py

@@ -0,0 +1,3 @@
+from agno.os.routers.registry.registry import get_registry_router
+
+__all__ = ["get_registry_router"]

agno/os/routers/registry/registry.py

@@ -0,0 +1,337 @@
+import time
+from typing import Any, Dict, List, Literal, Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import BaseModel, Field
+
+from agno.os.auth import get_authentication_dependency
+from agno.os.schema import (
+    BadRequestResponse,
+    InternalServerErrorResponse,
+    NotFoundResponse,
+    PaginatedResponse,
+    PaginationInfo,
+    UnauthenticatedResponse,
+    ValidationErrorResponse,
+)
+from agno.os.settings import AgnoAPISettings
+from agno.registry import Registry
+from agno.tools.function import Function
+from agno.tools.toolkit import Toolkit
+from agno.utils.log import log_error
+
+ComponentType = Literal["tool", "toolkit", "model", "db", "vector_db", "schema"]
+
+
+# ============================================
+# Response Schema
+# ============================================
+
+
+class ComponentResponse(BaseModel):
+    name: str
+    component_type: ComponentType
+    description: Optional[str] = None
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+    # Tool-specific fields (matching config format)
+    parameters: Optional[Dict[str, Any]] = None
+    requires_confirmation: Optional[bool] = None
+    external_execution: Optional[bool] = None
+
+
+# ============================================
+# Router
+# ============================================
+
+
+def get_registry_router(registry: Registry, settings: AgnoAPISettings = AgnoAPISettings()) -> APIRouter:
+    router = APIRouter(
+        dependencies=[Depends(get_authentication_dependency(settings))],
+        tags=["Registry"],
+        responses={
+            400: {"description": "Bad Request", "model": BadRequestResponse},
+            401: {"description": "Unauthorized", "model": UnauthenticatedResponse},
+            404: {"description": "Not Found", "model": NotFoundResponse},
+            422: {"description": "Validation Error", "model": ValidationErrorResponse},
+            500: {"description": "Internal Server Error", "model": InternalServerErrorResponse},
+        },
+    )
+    return attach_routes(router=router, registry=registry)
+
+
+def attach_routes(router: APIRouter, registry: Registry) -> APIRouter:
+    def _safe_str(v: Any) -> Optional[str]:
+        if v is None:
+            return None
+        if isinstance(v, str):
+            s = v.strip()
+            return s or None
+        return str(v)
+
+    def _safe_name(obj: Any, fallback: str) -> str:
+        n = getattr(obj, "name", None)
+        n = _safe_str(n)
+        return n or fallback
+
+    def _class_path(obj: Any) -> str:
+        cls = obj.__class__
+        return f"{cls.__module__}.{cls.__name__}"
+
+    def _maybe_jsonable(value: Any) -> Any:
+        # Best-effort: keep only data that is likely JSON serializable
+        # If your Function.parameters is a Pydantic model or custom object, this avoids 500s.
+        if value is None:
+            return None
+        if isinstance(value, (str, int, float, bool)):
+            return value
+        if isinstance(value, list):
+            return [_maybe_jsonable(x) for x in value]
+        if isinstance(value, dict):
+            out: Dict[str, Any] = {}
+            for k, v in value.items():
+                out[str(k)] = _maybe_jsonable(v)
+            return out
+        # Fallback to string to avoid serialization errors
+        return str(value)
+
+    def _get_all_components(include_schema: bool) -> List[ComponentResponse]:
+        components: List[ComponentResponse] = []
+
+        # Tools
+        for tool in getattr(registry, "tools", []) or []:
+            if isinstance(tool, Toolkit):
+                toolkit_name = _safe_name(tool, fallback=tool.__class__.__name__)
+                functions = getattr(tool, "functions", {}) or {}
+
+                components.append(
+                    ComponentResponse(
+                        name=toolkit_name,
+                        component_type="toolkit",
+                        description=_safe_str(getattr(tool, "description", None)),
+                        metadata={
+                            "class_path": _class_path(tool),
+                            "functions": sorted(list(functions.keys())),
+                        },
+                    )
+                )
+
+                # Also expose individual functions within toolkit
+                for func in functions.values():
+                    func_name = _safe_name(func, fallback=func.__class__.__name__)
+                    # Check if function requires confirmation or external execution
+                    # First check function-level settings, then toolkit-level settings
+                    requires_confirmation = getattr(func, "requires_confirmation", None)
+                    external_execution = getattr(func, "external_execution", None)
+
+                    # If not set on function, check toolkit settings
+                    if requires_confirmation is None and hasattr(tool, "requires_confirmation_tools"):
+                        requires_confirmation = func_name in (tool.requires_confirmation_tools or [])
+                    if external_execution is None and hasattr(tool, "external_execution_required_tools"):
+                        external_execution = func_name in (tool.external_execution_required_tools or [])
+
+                    # Get parameters - ensure they're processed if needed
+                    func_params = func.parameters
+                    # If parameters are empty/default and function has entrypoint, try to process it
+                    default_params = {"type": "object", "properties": {}, "required": []}
+                    if func_params == default_params and func.entrypoint and not func.skip_entrypoint_processing:
+                        try:
+                            # Create a copy to avoid modifying the original
+                            func_copy = func.model_copy(deep=False)
+                            func_copy.process_entrypoint(strict=False)
+                            func_params = func_copy.parameters
+                        except Exception:
+                            # If processing fails, use original parameters
+                            pass
+
+                    components.append(
+                        ComponentResponse(
+                            name=func_name,
+                            component_type="tool",
+                            description=_safe_str(getattr(func, "description", None)),
+                            parameters=_maybe_jsonable(func_params),
+                            requires_confirmation=requires_confirmation,
+                            external_execution=external_execution,
+                            metadata={
+                                "class_path": _class_path(func),
+                                "toolkit": toolkit_name,
+                                "has_entrypoint": bool(getattr(func, "entrypoint", None)),
+                            },
+                        )
+                    )
+
+            elif isinstance(tool, Function):
+                func_name = _safe_name(tool, fallback=tool.__class__.__name__)
+                requires_confirmation = getattr(tool, "requires_confirmation", None)
+                external_execution = getattr(tool, "external_execution", None)
+
+                # Get parameters - ensure they're processed if needed
+                func_params = tool.parameters
+                # If parameters are empty/default and function has entrypoint, try to process it
+                default_params = {"type": "object", "properties": {}, "required": []}
+                if func_params == default_params and tool.entrypoint and not tool.skip_entrypoint_processing:
+                    try:
+                        # Create a copy to avoid modifying the original
+                        tool_copy = tool.model_copy(deep=False)
+                        tool_copy.process_entrypoint(strict=False)
+                        func_params = tool_copy.parameters
+                    except Exception:
+                        # If processing fails, use original parameters
+                        pass
+
+                components.append(
+                    ComponentResponse(
+                        name=func_name,
+                        component_type="tool",
+                        description=_safe_str(getattr(tool, "description", None)),
+                        parameters=_maybe_jsonable(func_params),
+                        requires_confirmation=requires_confirmation,
+                        external_execution=external_execution,
+                        metadata={
+                            "class_path": _class_path(tool),
+                            "has_entrypoint": bool(getattr(tool, "entrypoint", None)),
+                        },
+                    )
+                )
+
+            elif callable(tool):
+                call_name = getattr(tool, "__name__", None) or tool.__class__.__name__
+                components.append(
+                    ComponentResponse(
+                        name=str(call_name),
+                        component_type="tool",
+                        description=_safe_str(getattr(tool, "__doc__", None)),
+                        metadata={"class_path": _class_path(tool)},
+                    )
+                )
+
+        # Models
+        for model in getattr(registry, "models", []) or []:
+            model_name = (
+                _safe_str(getattr(model, "id", None))
+                or _safe_str(getattr(model, "name", None))
+                or model.__class__.__name__
+            )
+            components.append(
+                ComponentResponse(
+                    name=model_name,
+                    component_type="model",
+                    description=_safe_str(getattr(model, "description", None)),
+                    metadata={
+                        "class_path": _class_path(model),
+                        "provider": _safe_str(getattr(model, "provider", None)),
+                        "model_id": _safe_str(getattr(model, "id", None)),
+                    },
+                )
+            )
+
+        # Databases
+        for db in getattr(registry, "dbs", []) or []:
+            db_name = (
+                _safe_str(getattr(db, "name", None))
+                or _safe_str(getattr(db, "id", None))
+                or _safe_str(getattr(db, "table_name", None))
+                or db.__class__.__name__
+            )
+            components.append(
+                ComponentResponse(
+                    name=db_name,
+                    component_type="db",
+                    metadata={
+                        "class_path": _class_path(db),
+                        "db_id": _safe_str(getattr(db, "id", None)),
+                        "table_name": _safe_str(getattr(db, "table_name", None)),
+                    },
+                )
+            )
+
+        # Vector databases
+        for vdb in getattr(registry, "vector_dbs", []) or []:
+            vdb_name = (
+                _safe_str(getattr(vdb, "name", None))
+                or _safe_str(getattr(vdb, "id", None))
+                or _safe_str(getattr(vdb, "collection", None))
+                or _safe_str(getattr(vdb, "table_name", None))
+                or vdb.__class__.__name__
+            )
+            components.append(
+                ComponentResponse(
+                    name=vdb_name,
+                    component_type="vector_db",
+                    metadata={
+                        "class_path": _class_path(vdb),
+                        "vector_db_id": _safe_str(getattr(vdb, "id", None)),
+                        "collection": _safe_str(getattr(vdb, "collection", None)),
+                        "table_name": _safe_str(getattr(vdb, "table_name", None)),
+                    },
+                )
+            )
+
+        # Schemas
+        for schema in getattr(registry, "schemas", []) or []:
+            schema_name = schema.__name__
+            meta: Dict[str, Any] = {"class_path": _class_path(schema)}
+            if include_schema:
+                try:
+                    meta["schema"] = schema.model_json_schema() if hasattr(schema, "model_json_schema") else {}
+                except Exception as e:
+                    meta["schema_error"] = str(e)
+
+            components.append(
+                ComponentResponse(
+                    name=schema_name,
+                    component_type="schema",
+                    metadata=meta,
+                )
+            )
+
+        # Stable ordering helps pagination
+        components.sort(key=lambda c: (c.component_type, c.name))
+        return components
+
+    @router.get(
+        "/registry",
+        response_model=PaginatedResponse[ComponentResponse],
+        response_model_exclude_none=True,
+        status_code=200,
+        operation_id="list_registry",
+        summary="List Registry",
+        description="List all components in the registry with optional filtering.",
+    )
+    async def list_registry(
+        component_type: Optional[ComponentType] = Query(None, description="Filter by component type"),
+        name: Optional[str] = Query(None, description="Filter by name (partial match)"),
+        include_schema: bool = Query(False, description="Include JSON schema for schema components"),
+        page: int = Query(1, ge=1, description="Page number"),
+        limit: int = Query(20, ge=1, le=100, description="Items per page"),
+    ) -> PaginatedResponse[ComponentResponse]:
+        try:
+            start_time_ms = time.time() * 1000
+            components = _get_all_components(include_schema=include_schema)
+
+            if component_type:
+                components = [c for c in components if c.component_type == component_type]
+
+            if name:
+                needle = name.lower().strip()
+                components = [c for c in components if needle in c.name.lower()]
+
+            total_count = len(components)
+            total_pages = (total_count + limit - 1) // limit if limit > 0 else 0
+            start_idx = (page - 1) * limit
+            paginated = components[start_idx : start_idx + limit]
+
+            return PaginatedResponse(
+                data=paginated,
+                meta=PaginationInfo(
+                    page=page,
+                    limit=limit,
+                    total_pages=total_pages,
+                    total_count=total_count,
+                    search_time_ms=round(time.time() * 1000 - start_time_ms, 2),
+                ),
+            )
+        except Exception as e:
+            log_error(f"Error listing components: {e}")
+            raise HTTPException(status_code=500, detail=str(e))
+
+    return router

agno/os/routers/teams/router.py

@@ -13,6 +13,7 @@ from fastapi import (
 )
 from fastapi.responses import JSONResponse, StreamingResponse
 
+from agno.db.base import BaseDb
 from agno.exceptions import InputCheckError, OutputCheckError
 from agno.media import Audio, Image, Video
 from agno.media import File as FileMedia
@@ -35,6 +36,7 @@ from agno.os.utils import (
     process_image,
     process_video,
 )
+from agno.registry import Registry
 from agno.run.team import RunErrorEvent as TeamRunErrorEvent
 from agno.team.remote import RemoteTeam
 from agno.team.team import Team
@@ -111,6 +113,7 @@ async def team_response_streamer(
 def get_team_router(
     os: "AgentOS",
     settings: AgnoAPISettings = AgnoAPISettings(),
+    registry: Optional[Registry] = None,
 ) -> APIRouter:
     """Create the team router with comprehensive OpenAPI documentation."""
     router = APIRouter(
@@ -165,6 +168,7 @@ def get_team_router(
         session_id: Optional[str] = Form(None),
         user_id: Optional[str] = Form(None),
         files: Optional[List[UploadFile]] = File(None),
+        version: Optional[int] = Form(None),
     ):
         kwargs = await get_request_kwargs(request, create_team_run)
 
@@ -194,7 +198,9 @@ def get_team_router(
 
         logger.debug(f"Creating team run: {message=} {session_id=} {monitor=} {user_id=} {team_id=} {files=} {kwargs=}")
 
-        team = get_team_by_id(team_id, os.teams, create_fresh=True)
+        team = get_team_by_id(
+            team_id=team_id, teams=os.teams, db=os.db, version=version, registry=registry, create_fresh=True
+        )
         if team is None:
             raise HTTPException(status_code=404, detail="Team not found")
 
@@ -321,7 +327,7 @@ def get_team_router(
         team_id: str,
         run_id: str,
     ):
-        team = get_team_by_id(team_id, os.teams, create_fresh=True)
+        team = get_team_by_id(team_id=team_id, teams=os.teams, db=os.db, registry=registry, create_fresh=True)
         if team is None:
             raise HTTPException(status_code=404, detail="Team not found")
 
@@ -414,9 +420,6 @@ def get_team_router(
     )
     async def get_teams(request: Request) -> List[TeamResponse]:
         """Return the list of all Teams present in the contextual OS"""
-        if os.teams is None:
-            return []
-
         # Filter teams based on user's scopes (only if authorization is enabled)
         if getattr(request.state, "authorization_enabled", False):
             from agno.os.auth import filter_resources_by_access, get_accessible_resources
@@ -426,9 +429,9 @@ def get_team_router(
             if not accessible_ids:
                 raise HTTPException(status_code=403, detail="Insufficient permissions")
 
-            accessible_teams = filter_resources_by_access(request, os.teams, "teams")
+            accessible_teams = filter_resources_by_access(request, os.teams or [], "teams")
         else:
-            accessible_teams = os.teams
+            accessible_teams = os.teams or []
 
         teams = []
         for team in accessible_teams:
@@ -438,6 +441,15 @@ def get_team_router(
                 team_response = await TeamResponse.from_team(team=team)
                 teams.append(team_response)
 
+        # Also load teams from database
+        if os.db and isinstance(os.db, BaseDb):
+            from agno.team.team import get_teams
+
+            db_teams = get_teams(db=os.db, registry=registry)
+            for db_team in db_teams:
+                team_response = await TeamResponse.from_team(team=db_team)
+                teams.append(team_response)
+
         return teams
 
     @router.get(
@@ -526,7 +538,7 @@ def get_team_router(
         dependencies=[Depends(require_resource_access("teams", "read", "team_id"))],
     )
     async def get_team(team_id: str, request: Request) -> TeamResponse:
-        team = get_team_by_id(team_id, os.teams, create_fresh=True)
+        team = get_team_by_id(team_id=team_id, teams=os.teams, db=os.db, registry=registry, create_fresh=True)
         if team is None:
             raise HTTPException(status_code=404, detail="Team not found")
 

agno/os/routers/teams/schema.py

@@ -65,7 +65,7 @@ class TeamResponse(BaseModel):
             "enable_agentic_knowledge_filters": False,
             # Memory defaults
             "enable_agentic_memory": False,
-            "enable_user_memories": False,
+            "update_memory_on_run": False,
             # Reasoning defaults
             "reasoning": False,
             "reasoning_min_steps": 1,
@@ -137,8 +137,9 @@ class TeamResponse(BaseModel):
             "cache_session": team.cache_session,
         }
 
+        contents_db = getattr(team.knowledge, "contents_db", None) if team.knowledge else None
         knowledge_info = {
-            "db_id": team.knowledge.contents_db.id if team.knowledge and team.knowledge.contents_db else None,
+            "db_id": contents_db.id if contents_db else None,
             "knowledge_table": knowledge_table,
             "enable_agentic_knowledge_filters": team.enable_agentic_knowledge_filters,
             "knowledge_filters": team.knowledge_filters,
@@ -149,9 +150,10 @@ class TeamResponse(BaseModel):
         if team.memory_manager is not None:
             memory_info = {
                 "enable_agentic_memory": team.enable_agentic_memory,
-                "enable_user_memories": team.enable_user_memories,
+                "update_memory_on_run": team.update_memory_on_run,
+                "enable_user_memories": team.enable_user_memories,  # Soon to be deprecated. Use update_memory_on_run
                 "metadata": team.metadata,
-                "memory_table": team.db.memory_table_name if team.db and team.enable_user_memories else None,
+                "memory_table": team.db.memory_table_name if team.db and team.update_memory_on_run else None,
             }
 
             if team.memory_manager.model is not None:

agno/os/routers/traces/traces.py

@@ -22,7 +22,7 @@ from agno.os.schema import (
     ValidationErrorResponse,
 )
 from agno.os.settings import AgnoAPISettings
-from agno.os.utils import get_db, parse_datetime_to_utc
+from agno.os.utils import get_db, timestamp_to_datetime
 from agno.remote.base import RemoteDb
 from agno.utils.log import log_error
 
@@ -159,8 +159,8 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
             start_time_ms = time_module.time() * 1000
 
             # Convert ISO datetime strings to UTC datetime objects
-            start_time_dt = parse_datetime_to_utc(start_time, "start_time") if start_time else None
-            end_time_dt = parse_datetime_to_utc(end_time, "end_time") if end_time else None
+            start_time_dt = timestamp_to_datetime(start_time, "start_time") if start_time else None
+            end_time_dt = timestamp_to_datetime(end_time, "end_time") if end_time else None
 
             if isinstance(db, AsyncBaseDb):
                 traces, total_count = await db.get_traces(
@@ -484,8 +484,8 @@ def attach_routes(router: APIRouter, dbs: dict[str, list[Union[BaseDb, AsyncBase
             start_time_ms = time_module.time() * 1000
 
             # Convert ISO datetime strings to UTC datetime objects
-            start_time_dt = parse_datetime_to_utc(start_time, "start_time") if start_time else None
-            end_time_dt = parse_datetime_to_utc(end_time, "end_time") if end_time else None
+            start_time_dt = timestamp_to_datetime(start_time, "start_time") if start_time else None
+            end_time_dt = timestamp_to_datetime(end_time, "end_time") if end_time else None
 
             if isinstance(db, AsyncBaseDb):
                 stats_list, total_count = await db.get_trace_stats(