agno 2.3.19__py3-none-any.whl → 2.3.20__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/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/knowledge/schemas.py

@@ -82,7 +82,7 @@ class ContentResponseSchema(BaseModel):
             status=status,
             status_message=content.get("status_message"),
             created_at=parse_timestamp(content.get("created_at")),
-            updated_at=parse_timestamp(content.get("updated_at")),
+            updated_at=parse_timestamp(content.get("updated_at", content.get("created_at", 0))),
             # TODO: These fields are not available in the Content class. Fix the inconsistency
             access_count=None,
             linked_to=None,

agno/os/routers/memory/schemas.py

@@ -1,3 +1,4 @@
+import json
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
@@ -25,12 +26,24 @@ class UserMemorySchema(BaseModel):
         if memory_dict["memory"] == "":
             return None
 
+        # Handle nested memory content (relevant for some memories migrated from v1)
+        if isinstance(memory_dict["memory"], dict):
+            if memory_dict["memory"].get("memory") is not None:
+                memory = str(memory_dict["memory"]["memory"])
+            else:
+                try:
+                    memory = json.dumps(memory_dict["memory"])
+                except json.JSONDecodeError:
+                    memory = str(memory_dict["memory"])
+        else:
+            memory = memory_dict["memory"]
+
         return cls(
             memory_id=memory_dict["memory_id"],
             user_id=str(memory_dict["user_id"]),
             agent_id=memory_dict.get("agent_id"),
             team_id=memory_dict.get("team_id"),
-            memory=memory_dict["memory"],
+            memory=memory,
             topics=memory_dict.get("topics", []),
             updated_at=memory_dict["updated_at"],
         )

agno/os/routers/metrics/schemas.py

@@ -35,7 +35,7 @@ class DayAggregatedMetrics(BaseModel):
             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", 0),
+            updated_at=metrics_dict.get("updated_at", metrics_dict.get("created_at", 0)),
             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/schema.py

@@ -193,7 +193,7 @@ class SessionSchema(BaseModel):
         session_data = session.get("session_data", {}) or {}
 
         created_at = session.get("created_at", 0)
-        updated_at = session.get("updated_at", 0)
+        updated_at = session.get("updated_at", created_at)
 
         # Handle created_at and updated_at as either ISO 8601 string or timestamp
         def parse_datetime(val):
@@ -213,7 +213,7 @@ class SessionSchema(BaseModel):
             return None
 
         created_at = parse_datetime(session.get("created_at", 0))
-        updated_at = parse_datetime(session.get("updated_at", 0))
+        updated_at = parse_datetime(session.get("updated_at", created_at))
         return cls(
             session_id=session.get("session_id", ""),
             session_name=session_name,
@@ -265,6 +265,8 @@ class AgentSessionDetailSchema(BaseModel):
     @classmethod
     def from_session(cls, session: AgentSession) -> "AgentSessionDetailSchema":
         session_name = get_session_name({**session.to_dict(), "session_type": "agent"})
+        created_at = datetime.fromtimestamp(session.created_at, tz=timezone.utc) if session.created_at else None
+        updated_at = datetime.fromtimestamp(session.updated_at, tz=timezone.utc) if session.updated_at else created_at
         return cls(
             user_id=session.user_id,
             agent_session_id=session.session_id,
@@ -280,8 +282,8 @@ class AgentSessionDetailSchema(BaseModel):
             metrics=session.session_data.get("session_metrics", {}) if session.session_data else None,  # type: ignore
             metadata=session.metadata,
             chat_history=[message.to_dict() for message in session.get_chat_history()],
-            created_at=datetime.fromtimestamp(session.created_at, tz=timezone.utc) if session.created_at else None,
-            updated_at=datetime.fromtimestamp(session.updated_at, tz=timezone.utc) if session.updated_at else None,
+            created_at=created_at,
+            updated_at=updated_at,
         )
 
 
@@ -304,7 +306,8 @@ class TeamSessionDetailSchema(BaseModel):
     def from_session(cls, session: TeamSession) -> "TeamSessionDetailSchema":
         session_dict = session.to_dict()
         session_name = get_session_name({**session_dict, "session_type": "team"})
-
+        created_at = datetime.fromtimestamp(session.created_at, tz=timezone.utc) if session.created_at else None
+        updated_at = datetime.fromtimestamp(session.updated_at, tz=timezone.utc) if session.updated_at else created_at
         return cls(
             session_id=session.session_id,
             team_id=session.team_id,
@@ -319,8 +322,8 @@ class TeamSessionDetailSchema(BaseModel):
             metrics=session.session_data.get("session_metrics", {}) if session.session_data else None,
             metadata=session.metadata,
             chat_history=[message.to_dict() for message in session.get_chat_history()],
-            created_at=datetime.fromtimestamp(session.created_at, tz=timezone.utc) if session.created_at else None,
-            updated_at=datetime.fromtimestamp(session.updated_at, tz=timezone.utc) if session.updated_at else None,
+            created_at=created_at,
+            updated_at=updated_at,
         )
 
 
@@ -343,7 +346,6 @@ class WorkflowSessionDetailSchema(BaseModel):
     def from_session(cls, session: WorkflowSession) -> "WorkflowSessionDetailSchema":
         session_dict = session.to_dict()
         session_name = get_session_name({**session_dict, "session_type": "workflow"})
-
         return cls(
             session_id=session.session_id,
             user_id=session.user_id,
@@ -355,7 +357,7 @@ class WorkflowSessionDetailSchema(BaseModel):
             workflow_data=session.workflow_data,
             metadata=session.metadata,
             created_at=session.created_at,
-            updated_at=session.updated_at,
+            updated_at=session.updated_at or session.created_at,
         )