agno 2.0.11__py3-none-any.whl → 2.1.1__py3-none-any.whl

agno/db/in_memory/in_memory_db.py

@@ -1,4 +1,5 @@
 import time
+from copy import deepcopy
 from datetime import date, datetime, timedelta, timezone
 from typing import Any, Dict, List, Optional, Tuple, Union
 from uuid import uuid4
@@ -107,15 +108,17 @@ class InMemoryDb(BaseDb):
                     if session_data.get("session_type") != session_type_value:
                         continue
 
+                    session_data_copy = deepcopy(session_data)
+
                     if not deserialize:
-                        return session_data
+                        return session_data_copy
 
                     if session_type == SessionType.AGENT:
-                        return AgentSession.from_dict(session_data)
+                        return AgentSession.from_dict(session_data_copy)
                     elif session_type == SessionType.TEAM:
-                        return TeamSession.from_dict(session_data)
+                        return TeamSession.from_dict(session_data_copy)
                     else:
-                        return WorkflowSession.from_dict(session_data)
+                        return WorkflowSession.from_dict(session_data_copy)
 
             return None
 
@@ -188,7 +191,7 @@ class InMemoryDb(BaseDb):
                 if session_data.get("session_type") != session_type_value:
                     continue
 
-                filtered_sessions.append(session_data)
+                filtered_sessions.append(deepcopy(session_data))
 
             total_count = len(filtered_sessions)
 
@@ -233,15 +236,16 @@ class InMemoryDb(BaseDb):
 
                     log_debug(f"Renamed session with id '{session_id}' to '{session_name}'")
 
+                    session_copy = deepcopy(session)
                     if not deserialize:
-                        return session
+                        return session_copy
 
                     if session_type == SessionType.AGENT:
-                        return AgentSession.from_dict(session)
+                        return AgentSession.from_dict(session_copy)
                     elif session_type == SessionType.TEAM:
-                        return TeamSession.from_dict(session)
+                        return TeamSession.from_dict(session_copy)
                     else:
-                        return WorkflowSession.from_dict(session)
+                        return WorkflowSession.from_dict(session_copy)
 
             return None
 
@@ -269,22 +273,26 @@ class InMemoryDb(BaseDb):
                 if existing_session.get("session_id") == session_dict.get("session_id") and self._matches_session_key(
                     existing_session, session
                 ):
-                    # Update existing session
                     session_dict["updated_at"] = int(time.time())
-                    self._sessions[i] = session_dict
+                    self._sessions[i] = deepcopy(session_dict)
                     session_updated = True
                     break
 
             if not session_updated:
-                # Add new session
                 session_dict["created_at"] = session_dict.get("created_at", int(time.time()))
                 session_dict["updated_at"] = session_dict.get("created_at")
-                self._sessions.append(session_dict)
+                self._sessions.append(deepcopy(session_dict))
 
+            session_dict_copy = deepcopy(session_dict)
             if not deserialize:
-                return session_dict
+                return session_dict_copy
 
-            return session
+            if session_dict_copy["session_type"] == SessionType.AGENT:
+                return AgentSession.from_dict(session_dict_copy)
+            elif session_dict_copy["session_type"] == SessionType.TEAM:
+                return TeamSession.from_dict(session_dict_copy)
+            else:
+                return WorkflowSession.from_dict(session_dict_copy)
 
         except Exception as e:
             log_error(f"Exception upserting session: {e}")
@@ -378,9 +386,10 @@ class InMemoryDb(BaseDb):
         try:
             for memory_data in self._memories:
                 if memory_data.get("memory_id") == memory_id:
+                    memory_data_copy = deepcopy(memory_data)
                     if not deserialize:
-                        return memory_data
-                    return UserMemory.from_dict(memory_data)
+                        return memory_data_copy
+                    return UserMemory.from_dict(memory_data_copy)
 
             return None
 
@@ -420,7 +429,7 @@ class InMemoryDb(BaseDb):
                     if search_content.lower() not in memory_content.lower():
                         continue
 
-                filtered_memories.append(memory_data)
+                filtered_memories.append(deepcopy(memory_data))
 
             total_count = len(filtered_memories)
 
@@ -499,9 +508,11 @@ class InMemoryDb(BaseDb):
             if not memory_updated:
                 self._memories.append(memory_dict)
 
+            memory_dict_copy = deepcopy(memory_dict)
             if not deserialize:
-                return memory_dict
-            return UserMemory.from_dict(memory_dict)
+                return memory_dict_copy
+
+            return UserMemory.from_dict(memory_dict_copy)
 
         except Exception as e:
             log_warning(f"Exception upserting user memory: {e}")
@@ -657,8 +668,8 @@ class InMemoryDb(BaseDb):
                 # Only include necessary fields for metrics
                 filtered_session = {
                     "user_id": session.get("user_id"),
-                    "session_data": session.get("session_data"),
-                    "runs": session.get("runs"),
+                    "session_data": deepcopy(session.get("session_data")),
+                    "runs": deepcopy(session.get("runs")),
                     "created_at": session.get("created_at"),
                     "session_type": session.get("session_type"),
                 }
@@ -688,7 +699,7 @@ class InMemoryDb(BaseDb):
                 if ending_date and metric_date > ending_date:
                     continue
 
-                filtered_metrics.append(metric)
+                filtered_metrics.append(deepcopy(metric))
 
                 updated_at = metric.get("updated_at")
                 if updated_at and (latest_updated_at is None or updated_at > latest_updated_at):
@@ -763,7 +774,7 @@ class InMemoryDb(BaseDb):
             Exception: If an error occurs during retrieval.
         """
         try:
-            knowledge_items = self._knowledge.copy()
+            knowledge_items = [deepcopy(item) for item in self._knowledge]
 
             total_count = len(knowledge_items)
 
@@ -858,9 +869,10 @@ class InMemoryDb(BaseDb):
         try:
             for run_data in self._eval_runs:
                 if run_data.get("run_id") == eval_run_id:
+                    run_data_copy = deepcopy(run_data)
                     if not deserialize:
-                        return run_data
-                    return EvalRunRecord.model_validate(run_data)
+                        return run_data_copy
+                    return EvalRunRecord.model_validate(run_data_copy)
 
             return None
 
@@ -906,7 +918,7 @@ class InMemoryDb(BaseDb):
                     elif filter_type == EvalFilterType.WORKFLOW and run_data.get("workflow_id") is None:
                         continue
 
-                filtered_runs.append(run_data)
+                filtered_runs.append(deepcopy(run_data))
 
             total_count = len(filtered_runs)
 
@@ -945,10 +957,11 @@ class InMemoryDb(BaseDb):
 
                     log_debug(f"Renamed eval run with id '{eval_run_id}' to '{name}'")
 
+                    run_data_copy = deepcopy(run_data)
                     if not deserialize:
-                        return run_data
+                        return run_data_copy
 
-                    return EvalRunRecord.model_validate(run_data)
+                    return EvalRunRecord.model_validate(run_data_copy)
 
             return None
 

agno/db/mongo/mongo.py

@@ -16,7 +16,7 @@ from agno.db.mongo.utils import (
 from agno.db.schemas.evals import EvalFilterType, EvalRunRecord, EvalType
 from agno.db.schemas.knowledge import KnowledgeRow
 from agno.db.schemas.memory import UserMemory
-from agno.db.utils import deserialize_session_json_fields, serialize_session_json_fields
+from agno.db.utils import deserialize_session_json_fields
 from agno.session import AgentSession, Session, TeamSession, WorkflowSession
 from agno.utils.log import log_debug, log_error, log_info
 from agno.utils.string import generate_id
@@ -282,7 +282,6 @@ class MongoDb(BaseDb):
                 return None
 
             session = deserialize_session_json_fields(result)
-
             if not deserialize:
                 return session
 
@@ -385,7 +384,6 @@ class MongoDb(BaseDb):
             records = list(cursor)
             if records is None:
                 return [] if deserialize else ([], 0)
-
             sessions_raw = [deserialize_session_json_fields(record) for record in records]
 
             if not deserialize:
@@ -489,25 +487,25 @@ class MongoDb(BaseDb):
             if collection is None:
                 return None
 
-            serialized_session_dict = serialize_session_json_fields(session.to_dict())
+            session_dict = session.to_dict()
 
             if isinstance(session, AgentSession):
                 record = {
-                    "session_id": serialized_session_dict.get("session_id"),
+                    "session_id": session_dict.get("session_id"),
                     "session_type": SessionType.AGENT.value,
-                    "agent_id": serialized_session_dict.get("agent_id"),
-                    "user_id": serialized_session_dict.get("user_id"),
-                    "runs": serialized_session_dict.get("runs"),
-                    "agent_data": serialized_session_dict.get("agent_data"),
-                    "session_data": serialized_session_dict.get("session_data"),
-                    "summary": serialized_session_dict.get("summary"),
-                    "metadata": serialized_session_dict.get("metadata"),
-                    "created_at": serialized_session_dict.get("created_at"),
+                    "agent_id": session_dict.get("agent_id"),
+                    "user_id": session_dict.get("user_id"),
+                    "runs": session_dict.get("runs"),
+                    "agent_data": session_dict.get("agent_data"),
+                    "session_data": session_dict.get("session_data"),
+                    "summary": session_dict.get("summary"),
+                    "metadata": session_dict.get("metadata"),
+                    "created_at": session_dict.get("created_at"),
                     "updated_at": int(time.time()),
                 }
 
                 result = collection.find_one_and_replace(
-                    filter={"session_id": serialized_session_dict.get("session_id")},
+                    filter={"session_id": session_dict.get("session_id")},
                     replacement=record,
                     upsert=True,
                     return_document=ReturnDocument.AFTER,
@@ -515,7 +513,7 @@ class MongoDb(BaseDb):
                 if not result:
                     return None
 
-                session = deserialize_session_json_fields(result)  # type: ignore
+                session = result  # type: ignore
 
                 if not deserialize:
                     return session
@@ -524,21 +522,21 @@ class MongoDb(BaseDb):
 
             elif isinstance(session, TeamSession):
                 record = {
-                    "session_id": serialized_session_dict.get("session_id"),
+                    "session_id": session_dict.get("session_id"),
                     "session_type": SessionType.TEAM.value,
-                    "team_id": serialized_session_dict.get("team_id"),
-                    "user_id": serialized_session_dict.get("user_id"),
-                    "runs": serialized_session_dict.get("runs"),
-                    "team_data": serialized_session_dict.get("team_data"),
-                    "session_data": serialized_session_dict.get("session_data"),
-                    "summary": serialized_session_dict.get("summary"),
-                    "metadata": serialized_session_dict.get("metadata"),
-                    "created_at": serialized_session_dict.get("created_at"),
+                    "team_id": session_dict.get("team_id"),
+                    "user_id": session_dict.get("user_id"),
+                    "runs": session_dict.get("runs"),
+                    "team_data": session_dict.get("team_data"),
+                    "session_data": session_dict.get("session_data"),
+                    "summary": session_dict.get("summary"),
+                    "metadata": session_dict.get("metadata"),
+                    "created_at": session_dict.get("created_at"),
                     "updated_at": int(time.time()),
                 }
 
                 result = collection.find_one_and_replace(
-                    filter={"session_id": serialized_session_dict.get("session_id")},
+                    filter={"session_id": session_dict.get("session_id")},
                     replacement=record,
                     upsert=True,
                     return_document=ReturnDocument.AFTER,
@@ -546,7 +544,8 @@ class MongoDb(BaseDb):
                 if not result:
                     return None
 
-                session = deserialize_session_json_fields(result)  # type: ignore
+                # MongoDB stores native objects, no deserialization needed for document fields
+                session = result  # type: ignore
 
                 if not deserialize:
                     return session
@@ -555,21 +554,21 @@ class MongoDb(BaseDb):
 
             else:
                 record = {
-                    "session_id": serialized_session_dict.get("session_id"),
+                    "session_id": session_dict.get("session_id"),
                     "session_type": SessionType.WORKFLOW.value,
-                    "workflow_id": serialized_session_dict.get("workflow_id"),
-                    "user_id": serialized_session_dict.get("user_id"),
-                    "runs": serialized_session_dict.get("runs"),
-                    "workflow_data": serialized_session_dict.get("workflow_data"),
-                    "session_data": serialized_session_dict.get("session_data"),
-                    "summary": serialized_session_dict.get("summary"),
-                    "metadata": serialized_session_dict.get("metadata"),
-                    "created_at": serialized_session_dict.get("created_at"),
+                    "workflow_id": session_dict.get("workflow_id"),
+                    "user_id": session_dict.get("user_id"),
+                    "runs": session_dict.get("runs"),
+                    "workflow_data": session_dict.get("workflow_data"),
+                    "session_data": session_dict.get("session_data"),
+                    "summary": session_dict.get("summary"),
+                    "metadata": session_dict.get("metadata"),
+                    "created_at": session_dict.get("created_at"),
                     "updated_at": int(time.time()),
                 }
 
                 result = collection.find_one_and_replace(
-                    filter={"session_id": serialized_session_dict.get("session_id")},
+                    filter={"session_id": session_dict.get("session_id")},
                     replacement=record,
                     upsert=True,
                     return_document=ReturnDocument.AFTER,
@@ -577,7 +576,7 @@ class MongoDb(BaseDb):
                 if not result:
                     return None
 
-                session = deserialize_session_json_fields(result)  # type: ignore
+                session = result  # type: ignore
 
                 if not deserialize:
                     return session
@@ -628,48 +627,48 @@ class MongoDb(BaseDb):
                 if session is None:
                     continue
 
-                serialized_session_dict = serialize_session_json_fields(session.to_dict())
+                session_dict = session.to_dict()
 
                 if isinstance(session, AgentSession):
                     record = {
-                        "session_id": serialized_session_dict.get("session_id"),
+                        "session_id": session_dict.get("session_id"),
                         "session_type": SessionType.AGENT.value,
-                        "agent_id": serialized_session_dict.get("agent_id"),
-                        "user_id": serialized_session_dict.get("user_id"),
-                        "runs": serialized_session_dict.get("runs"),
-                        "agent_data": serialized_session_dict.get("agent_data"),
-                        "session_data": serialized_session_dict.get("session_data"),
-                        "summary": serialized_session_dict.get("summary"),
-                        "metadata": serialized_session_dict.get("metadata"),
-                        "created_at": serialized_session_dict.get("created_at"),
+                        "agent_id": session_dict.get("agent_id"),
+                        "user_id": session_dict.get("user_id"),
+                        "runs": session_dict.get("runs"),
+                        "agent_data": session_dict.get("agent_data"),
+                        "session_data": session_dict.get("session_data"),
+                        "summary": session_dict.get("summary"),
+                        "metadata": session_dict.get("metadata"),
+                        "created_at": session_dict.get("created_at"),
                         "updated_at": int(time.time()),
                     }
                 elif isinstance(session, TeamSession):
                     record = {
-                        "session_id": serialized_session_dict.get("session_id"),
+                        "session_id": session_dict.get("session_id"),
                         "session_type": SessionType.TEAM.value,
-                        "team_id": serialized_session_dict.get("team_id"),
-                        "user_id": serialized_session_dict.get("user_id"),
-                        "runs": serialized_session_dict.get("runs"),
-                        "team_data": serialized_session_dict.get("team_data"),
-                        "session_data": serialized_session_dict.get("session_data"),
-                        "summary": serialized_session_dict.get("summary"),
-                        "metadata": serialized_session_dict.get("metadata"),
-                        "created_at": serialized_session_dict.get("created_at"),
+                        "team_id": session_dict.get("team_id"),
+                        "user_id": session_dict.get("user_id"),
+                        "runs": session_dict.get("runs"),
+                        "team_data": session_dict.get("team_data"),
+                        "session_data": session_dict.get("session_data"),
+                        "summary": session_dict.get("summary"),
+                        "metadata": session_dict.get("metadata"),
+                        "created_at": session_dict.get("created_at"),
                         "updated_at": int(time.time()),
                     }
                 elif isinstance(session, WorkflowSession):
                     record = {
-                        "session_id": serialized_session_dict.get("session_id"),
+                        "session_id": session_dict.get("session_id"),
                         "session_type": SessionType.WORKFLOW.value,
-                        "workflow_id": serialized_session_dict.get("workflow_id"),
-                        "user_id": serialized_session_dict.get("user_id"),
-                        "runs": serialized_session_dict.get("runs"),
-                        "workflow_data": serialized_session_dict.get("workflow_data"),
-                        "session_data": serialized_session_dict.get("session_data"),
-                        "summary": serialized_session_dict.get("summary"),
-                        "metadata": serialized_session_dict.get("metadata"),
-                        "created_at": serialized_session_dict.get("created_at"),
+                        "workflow_id": session_dict.get("workflow_id"),
+                        "user_id": session_dict.get("user_id"),
+                        "runs": session_dict.get("runs"),
+                        "workflow_data": session_dict.get("workflow_data"),
+                        "session_data": session_dict.get("session_data"),
+                        "summary": session_dict.get("summary"),
+                        "metadata": session_dict.get("metadata"),
+                        "created_at": session_dict.get("created_at"),
                         "updated_at": int(time.time()),
                     }
                 else:
@@ -688,7 +687,7 @@ class MongoDb(BaseDb):
                 cursor = collection.find({"session_id": {"$in": session_ids}})
 
                 for doc in cursor:
-                    session_dict = deserialize_session_json_fields(doc)
+                    session_dict = doc
 
                     if deserialize:
                         session_type = doc.get("session_type")

agno/db/postgres/postgres.py

@@ -756,7 +756,7 @@ class PostgresDb(BaseDb):
                     )
 
                 with self.Session() as sess, sess.begin():
-                    stmt = postgresql.insert(table)
+                    stmt: Any = postgresql.insert(table)
                     update_columns = {
                         col.name: stmt.excluded[col.name]
                         for col in table.columns
@@ -1263,13 +1263,15 @@ class PostgresDb(BaseDb):
             results: List[Union[UserMemory, Dict[str, Any]]] = []
 
             with self.Session() as sess, sess.begin():
-                stmt = postgresql.insert(table)
+                insert_stmt = postgresql.insert(table)
                 update_columns = {
-                    col.name: stmt.excluded[col.name]
+                    col.name: insert_stmt.excluded[col.name]
                     for col in table.columns
                     if col.name not in ["memory_id"]  # Don't update primary key
                 }
-                stmt = stmt.on_conflict_do_update(index_elements=["memory_id"], set_=update_columns).returning(table)
+                stmt = insert_stmt.on_conflict_do_update(index_elements=["memory_id"], set_=update_columns).returning(
+                    table
+                )
 
                 result = sess.execute(stmt, memory_records)
                 for row in result.fetchall():

agno/db/utils.py

@@ -4,7 +4,6 @@ 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
 
@@ -55,34 +54,63 @@ def serialize_session_json_fields(session: dict) -> dict:
 
 
 def deserialize_session_json_fields(session: dict) -> dict:
-    """Deserialize all JSON fields in the given Session dictionary.
+    """Deserialize JSON fields in the given Session dictionary.
 
     Args:
         session (dict): The dictionary to deserialize.
 
     Returns:
-        dict: The dictionary with JSON fields deserialized.
+        dict: The dictionary with JSON string fields deserialized to objects.
     """
-    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"])
+    from agno.utils.log import log_warning
+
+    if session.get("agent_data") is not None and isinstance(session["agent_data"], str):
+        try:
+            session["agent_data"] = json.loads(session["agent_data"])
+        except (json.JSONDecodeError, TypeError) as e:
+            log_warning(f"Warning: Could not parse agent_data as JSON, keeping as string: {e}")
+
+    if session.get("team_data") is not None and isinstance(session["team_data"], str):
+        try:
+            session["team_data"] = json.loads(session["team_data"])
+        except (json.JSONDecodeError, TypeError) as e:
+            log_warning(f"Warning: Could not parse team_data as JSON, keeping as string: {e}")
+
+    if session.get("workflow_data") is not None and isinstance(session["workflow_data"], str):
+        try:
+            session["workflow_data"] = json.loads(session["workflow_data"])
+        except (json.JSONDecodeError, TypeError) as e:
+            log_warning(f"Warning: Could not parse workflow_data as JSON, keeping as string: {e}")
+
+    if session.get("metadata") is not None and isinstance(session["metadata"], str):
+        try:
+            session["metadata"] = json.loads(session["metadata"])
+        except (json.JSONDecodeError, TypeError) as e:
+            log_warning(f"Warning: Could not parse metadata as JSON, keeping as string: {e}")
+
+    if session.get("chat_history") is not None and isinstance(session["chat_history"], str):
+        try:
+            session["chat_history"] = json.loads(session["chat_history"])
+        except (json.JSONDecodeError, TypeError) as e:
+            log_warning(f"Warning: Could not parse chat_history as JSON, keeping as string: {e}")
+
+    if session.get("summary") is not None and isinstance(session["summary"], str):
+        try:
+            session["summary"] = json.loads(session["summary"])
+        except (json.JSONDecodeError, TypeError) as e:
+            log_warning(f"Warning: Could not parse summary as JSON, keeping as string: {e}")
+
     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:
+        try:
+            session["session_data"] = json.loads(session["session_data"])
+        except (json.JSONDecodeError, TypeError) as e:
+            log_warning(f"Warning: Could not parse session_data as JSON, keeping as string: {e}")
+
+    # Handle runs field with session type checking
+    if session.get("runs") is not None and isinstance(session["runs"], str):
+        try:
             session["runs"] = json.loads(session["runs"])
+        except (json.JSONDecodeError, TypeError) as e:
+            log_warning(f"Warning: Could not parse runs as JSON, keeping as string: {e}")
 
     return session