agno 2.1.0__py3-none-any.whl → 2.1.2__py3-none-any.whl

agno/agent/agent.py

@@ -5244,7 +5244,7 @@ class Agent:
 
         # 3.2.5 Add information about agentic filters if enabled
         if self.knowledge is not None and self.enable_agentic_knowledge_filters:
-            valid_filters = getattr(self.knowledge, "valid_metadata_filters", None)
+            valid_filters = self.knowledge.get_valid_filters()
             if valid_filters:
                 valid_filters_str = ", ".join(valid_filters)
                 additional_information.append(
@@ -6420,6 +6420,12 @@ class Agent:
                         log_warning("Reasoning error. Reasoning response is empty, continuing regular session...")
                         break
 
+                    if isinstance(reasoning_agent_response.content, str):
+                        log_warning(
+                            "Reasoning error. Content is a string, not structured output. Continuing regular session..."
+                        )
+                        break
+
                     if (
                         reasoning_agent_response.content.reasoning_steps is None
                         or len(reasoning_agent_response.content.reasoning_steps) == 0
@@ -6649,6 +6655,12 @@ class Agent:
                         log_warning("Reasoning error. Reasoning response is empty, continuing regular session...")
                         break
 
+                    if isinstance(reasoning_agent_response.content, str):
+                        log_warning(
+                            "Reasoning error. Content is a string, not structured output. Continuing regular session..."
+                        )
+                        break
+
                     if reasoning_agent_response.content.reasoning_steps is None:
                         log_warning("Reasoning error. Reasoning steps are empty, continuing regular session...")
                         break

agno/db/base.py

@@ -95,20 +95,23 @@ class BaseDb(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def delete_user_memory(self, memory_id: str) -> None:
+    def delete_user_memory(self, memory_id: str, user_id: Optional[str] = None) -> None:
         raise NotImplementedError
 
     @abstractmethod
-    def delete_user_memories(self, memory_ids: List[str]) -> None:
+    def delete_user_memories(self, memory_ids: List[str], user_id: Optional[str] = None) -> None:
         raise NotImplementedError
 
     @abstractmethod
-    def get_all_memory_topics(self) -> List[str]:
+    def get_all_memory_topics(self, user_id: Optional[str] = None) -> List[str]:
         raise NotImplementedError
 
     @abstractmethod
     def get_user_memory(
-        self, memory_id: str, deserialize: Optional[bool] = True
+        self,
+        memory_id: str,
+        deserialize: Optional[bool] = True,
+        user_id: Optional[str] = None,
     ) -> Optional[Union[UserMemory, Dict[str, Any]]]:
         raise NotImplementedError
 
@@ -133,6 +136,7 @@ class BaseDb(ABC):
         self,
         limit: Optional[int] = None,
         page: Optional[int] = None,
+        user_id: Optional[str] = None,
     ) -> Tuple[List[Dict[str, Any]], int]:
         raise NotImplementedError
 

agno/db/dynamo/dynamo.py

@@ -562,17 +562,31 @@ class DynamoDb(BaseDb):
 
     # --- User Memory ---
 
-    def delete_user_memory(self, memory_id: str) -> None:
+    def delete_user_memory(self, memory_id: str, user_id: Optional[str] = None) -> None:
         """
         Delete a user memory from the database.
 
         Args:
             memory_id: The ID of the memory to delete.
+            user_id: The ID of the user (optional, for filtering).
 
         Raises:
             Exception: If any error occurs while deleting the user memory.
         """
         try:
+            # If user_id is provided, verify the memory belongs to the user before deleting
+            if user_id:
+                response = self.client.get_item(
+                    TableName=self.memory_table_name,
+                    Key={"memory_id": {"S": memory_id}},
+                )
+                item = response.get("Item")
+                if item:
+                    memory_data = deserialize_from_dynamodb_item(item)
+                    if memory_data.get("user_id") != user_id:
+                        log_debug(f"Memory {memory_id} does not belong to user {user_id}")
+                        return
+
             self.client.delete_item(
                 TableName=self.memory_table_name,
                 Key={"memory_id": {"S": memory_id}},
@@ -583,18 +597,34 @@ class DynamoDb(BaseDb):
             log_error(f"Failed to delete user memory {memory_id}: {e}")
             raise e
 
-    def delete_user_memories(self, memory_ids: List[str]) -> None:
+    def delete_user_memories(self, memory_ids: List[str], user_id: Optional[str] = None) -> None:
         """
         Delete user memories from the database in batches.
 
         Args:
             memory_ids: List of memory IDs to delete
+            user_id: The ID of the user (optional, for filtering).
 
         Raises:
             Exception: If any error occurs while deleting the user memories.
         """
 
         try:
+            # If user_id is provided, filter memory_ids to only those belonging to the user
+            if user_id:
+                filtered_memory_ids = []
+                for memory_id in memory_ids:
+                    response = self.client.get_item(
+                        TableName=self.memory_table_name,
+                        Key={"memory_id": {"S": memory_id}},
+                    )
+                    item = response.get("Item")
+                    if item:
+                        memory_data = deserialize_from_dynamodb_item(item)
+                        if memory_data.get("user_id") == user_id:
+                            filtered_memory_ids.append(memory_id)
+                memory_ids = filtered_memory_ids
+
             for i in range(0, len(memory_ids), DYNAMO_BATCH_SIZE_LIMIT):
                 batch = memory_ids[i : i + DYNAMO_BATCH_SIZE_LIMIT]
 
@@ -611,6 +641,9 @@ class DynamoDb(BaseDb):
     def get_all_memory_topics(self) -> List[str]:
         """Get all memory topics from the database.
 
+        Args:
+            user_id: The ID of the user (optional, for filtering).
+
         Returns:
             List[str]: List of unique memory topics.
         """
@@ -619,13 +652,17 @@ class DynamoDb(BaseDb):
             if table_name is None:
                 return []
 
-            # Scan the entire table to get all memories
-            response = self.client.scan(TableName=table_name)
+            # Build filter expression for user_id if provided
+            scan_kwargs = {"TableName": table_name}
+
+            # Scan the table to get memories
+            response = self.client.scan(**scan_kwargs)
             items = response.get("Items", [])
 
             # Handle pagination
             while "LastEvaluatedKey" in response:
-                response = self.client.scan(TableName=table_name, ExclusiveStartKey=response["LastEvaluatedKey"])
+                scan_kwargs["ExclusiveStartKey"] = response["LastEvaluatedKey"]
+                response = self.client.scan(**scan_kwargs)
                 items.extend(response.get("Items", []))
 
             # Extract topics from all memories
@@ -642,13 +679,18 @@ class DynamoDb(BaseDb):
             raise e
 
     def get_user_memory(
-        self, memory_id: str, deserialize: Optional[bool] = True
+        self,
+        memory_id: str,
+        deserialize: Optional[bool] = True,
+        user_id: Optional[str] = None,
     ) -> Optional[Union[UserMemory, Dict[str, Any]]]:
         """
         Get a user memory from the database as a UserMemory object.
 
         Args:
             memory_id: The ID of the memory to get.
+            deserialize: Whether to deserialize the memory.
+            user_id: The ID of the user (optional, for filtering).
 
         Returns:
             Optional[UserMemory]: The user memory data if found, None otherwise.
@@ -665,6 +707,11 @@ class DynamoDb(BaseDb):
                 return None
 
             item = deserialize_from_dynamodb_item(item)
+
+            # Filter by user_id if provided
+            if user_id and item.get("user_id") != user_id:
+                return None
+
             if not deserialize:
                 return item
 
@@ -804,6 +851,7 @@ class DynamoDb(BaseDb):
         Args:
             limit (Optional[int]): The maximum number of user stats to return.
             page (Optional[int]): The page number.
+            user_id (Optional[str]): The ID of the user (optional, for filtering).
 
         Returns:
             Tuple[List[Dict[str, Any]], int]: A list of dictionaries containing user stats and total count.
@@ -823,29 +871,33 @@ class DynamoDb(BaseDb):
         try:
             table_name = self._get_table("memories")
 
-            response = self.client.scan(TableName=table_name)
+            # Build filter expression for user_id if provided
+            scan_kwargs = {"TableName": table_name}
+
+            response = self.client.scan(**scan_kwargs)
             items = response.get("Items", [])
 
             # Handle pagination
             while "LastEvaluatedKey" in response:
-                response = self.client.scan(TableName=table_name, ExclusiveStartKey=response["LastEvaluatedKey"])
+                scan_kwargs["ExclusiveStartKey"] = response["LastEvaluatedKey"]
+                response = self.client.scan(**scan_kwargs)
                 items.extend(response.get("Items", []))
 
             # Aggregate stats by user_id
             user_stats = {}
             for item in items:
                 memory_data = deserialize_from_dynamodb_item(item)
-                user_id = memory_data.get("user_id")
+                current_user_id = memory_data.get("user_id")
 
-                if user_id:
-                    if user_id not in user_stats:
-                        user_stats[user_id] = {
-                            "user_id": user_id,
+                if current_user_id:
+                    if current_user_id not in user_stats:
+                        user_stats[current_user_id] = {
+                            "user_id": current_user_id,
                             "total_memories": 0,
                             "last_memory_updated_at": None,
                         }
 
-                    user_stats[user_id]["total_memories"] += 1
+                    user_stats[current_user_id]["total_memories"] += 1
 
                     updated_at = memory_data.get("updated_at")
                     if updated_at:
@@ -853,10 +905,10 @@ class DynamoDb(BaseDb):
                         updated_at_timestamp = int(updated_at_dt.timestamp())
 
                         if updated_at_timestamp and (
-                            user_stats[user_id]["last_memory_updated_at"] is None
-                            or updated_at_timestamp > user_stats[user_id]["last_memory_updated_at"]
+                            user_stats[current_user_id]["last_memory_updated_at"] is None
+                            or updated_at_timestamp > user_stats[current_user_id]["last_memory_updated_at"]
                         ):
-                            user_stats[user_id]["last_memory_updated_at"] = updated_at_timestamp
+                            user_stats[current_user_id]["last_memory_updated_at"] = updated_at_timestamp
 
             # Convert to list and apply sorting
             stats_list = list(user_stats.values())

agno/db/firestore/firestore.py

@@ -596,11 +596,12 @@ class FirestoreDb(BaseDb):
 
     # -- Memory methods --
 
-    def delete_user_memory(self, memory_id: str):
+    def delete_user_memory(self, memory_id: str, user_id: Optional[str] = None):
         """Delete a user memory from the database.
 
         Args:
             memory_id (str): The ID of the memory to delete.
+            user_id (Optional[str]): The ID of the user (optional, for filtering).
 
         Returns:
             bool: True if the memory was deleted, False otherwise.
@@ -610,28 +611,41 @@ class FirestoreDb(BaseDb):
         """
         try:
             collection_ref = self._get_collection(table_type="memories")
-            docs = collection_ref.where(filter=FieldFilter("memory_id", "==", memory_id)).stream()
 
-            deleted_count = 0
-            for doc in docs:
-                doc.reference.delete()
-                deleted_count += 1
-
-            success = deleted_count > 0
-            if success:
-                log_debug(f"Successfully deleted user memory id: {memory_id}")
+            # If user_id is provided, verify the memory belongs to the user before deleting
+            if user_id:
+                docs = collection_ref.where(filter=FieldFilter("memory_id", "==", memory_id)).stream()
+                for doc in docs:
+                    data = doc.to_dict()
+                    if data.get("user_id") != user_id:
+                        log_debug(f"Memory {memory_id} does not belong to user {user_id}")
+                        return
+                    doc.reference.delete()
+                    log_debug(f"Successfully deleted user memory id: {memory_id}")
+                    return
             else:
-                log_debug(f"No user memory found with id: {memory_id}")
+                docs = collection_ref.where(filter=FieldFilter("memory_id", "==", memory_id)).stream()
+                deleted_count = 0
+                for doc in docs:
+                    doc.reference.delete()
+                    deleted_count += 1
+
+                success = deleted_count > 0
+                if success:
+                    log_debug(f"Successfully deleted user memory id: {memory_id}")
+                else:
+                    log_debug(f"No user memory found with id: {memory_id}")
 
         except Exception as e:
             log_error(f"Error deleting user memory: {e}")
             raise e
 
-    def delete_user_memories(self, memory_ids: List[str]) -> None:
+    def delete_user_memories(self, memory_ids: List[str], user_id: Optional[str] = None) -> None:
         """Delete user memories from the database.
 
         Args:
             memory_ids (List[str]): The IDs of the memories to delete.
+            user_id (Optional[str]): The ID of the user (optional, for filtering).
 
         Raises:
             Exception: If there is an error deleting the memories.
@@ -641,11 +655,21 @@ class FirestoreDb(BaseDb):
             batch = self.db_client.batch()
             deleted_count = 0
 
-            for memory_id in memory_ids:
-                docs = collection_ref.where(filter=FieldFilter("memory_id", "==", memory_id)).stream()
-                for doc in docs:
-                    batch.delete(doc.reference)
-                    deleted_count += 1
+            # If user_id is provided, filter memory_ids to only those belonging to the user
+            if user_id:
+                for memory_id in memory_ids:
+                    docs = collection_ref.where(filter=FieldFilter("memory_id", "==", memory_id)).stream()
+                    for doc in docs:
+                        data = doc.to_dict()
+                        if data.get("user_id") == user_id:
+                            batch.delete(doc.reference)
+                            deleted_count += 1
+            else:
+                for memory_id in memory_ids:
+                    docs = collection_ref.where(filter=FieldFilter("memory_id", "==", memory_id)).stream()
+                    for doc in docs:
+                        batch.delete(doc.reference)
+                        deleted_count += 1
 
             batch.commit()
 
@@ -658,7 +682,9 @@ class FirestoreDb(BaseDb):
             log_error(f"Error deleting memories: {e}")
             raise e
 
-    def get_all_memory_topics(self, create_collection_if_not_found: Optional[bool] = True) -> List[str]:
+    def get_all_memory_topics(
+        self, create_collection_if_not_found: Optional[bool] = True
+    ) -> List[str]:
         """Get all memory topics from the database.
 
         Returns:
@@ -687,12 +713,15 @@ class FirestoreDb(BaseDb):
             log_error(f"Exception getting all memory topics: {e}")
             raise e
 
-    def get_user_memory(self, memory_id: str, deserialize: Optional[bool] = True) -> Optional[UserMemory]:
+    def get_user_memory(
+        self, memory_id: str, deserialize: Optional[bool] = True, user_id: Optional[str] = None
+    ) -> Optional[UserMemory]:
         """Get a memory from the database.
 
         Args:
             memory_id (str): The ID of the memory to get.
             deserialize (Optional[bool]): Whether to serialize the memory. Defaults to True.
+            user_id (Optional[str]): The ID of the user (optional, for filtering).
 
         Returns:
             Optional[UserMemory]:
@@ -711,7 +740,14 @@ class FirestoreDb(BaseDb):
                 result = doc.to_dict()
                 break
 
-            if result is None or not deserialize:
+            if result is None:
+                return None
+
+            # Filter by user_id if provided
+            if user_id and result.get("user_id") != user_id:
+                return None
+
+            if not deserialize:
                 return result
 
             return UserMemory.from_dict(result)
@@ -818,23 +854,26 @@ class FirestoreDb(BaseDb):
         """
         try:
             collection_ref = self._get_collection(table_type="memories")
-            docs = collection_ref.where(filter=FieldFilter("user_id", "!=", None)).stream()
+
+            query = collection_ref.where(filter=FieldFilter("user_id", "!=", None))
+
+            docs = query.stream()
 
             user_stats = {}
             for doc in docs:
                 data = doc.to_dict()
-                user_id = data.get("user_id")
-                if user_id:
-                    if user_id not in user_stats:
-                        user_stats[user_id] = {
-                            "user_id": user_id,
+                current_user_id = data.get("user_id")
+                if current_user_id:
+                    if current_user_id not in user_stats:
+                        user_stats[current_user_id] = {
+                            "user_id": current_user_id,
                             "total_memories": 0,
                             "last_memory_updated_at": 0,
                         }
-                    user_stats[user_id]["total_memories"] += 1
+                    user_stats[current_user_id]["total_memories"] += 1
                     updated_at = data.get("updated_at", 0)
-                    if updated_at > user_stats[user_id]["last_memory_updated_at"]:
-                        user_stats[user_id]["last_memory_updated_at"] = updated_at
+                    if updated_at > user_stats[current_user_id]["last_memory_updated_at"]:
+                        user_stats[current_user_id]["last_memory_updated_at"] = updated_at
 
             # Convert to list and sort
             formatted_results = list(user_stats.values())

agno/db/gcs_json/gcs_json_db.py

@@ -459,12 +459,22 @@ class GcsJsonDb(BaseDb):
         return False
 
     # -- Memory methods --
-    def delete_user_memory(self, memory_id: str) -> None:
-        """Delete a user memory from the GCS JSON file."""
+    def delete_user_memory(self, memory_id: str, user_id: Optional[str] = None) -> None:
+        """Delete a user memory from the GCS JSON file.
+
+        Args:
+            memory_id (str): The ID of the memory to delete.
+            user_id (Optional[str]): The ID of the user. If provided, verifies ownership before deletion.
+        """
         try:
             memories = self._read_json_file(self.memory_table_name)
             original_count = len(memories)
-            memories = [m for m in memories if m.get("memory_id") != memory_id]
+
+            # Filter out the memory, with optional user_id verification
+            memories = [
+                m for m in memories
+                if not (m.get("memory_id") == memory_id and (user_id is None or m.get("user_id") == user_id))
+            ]
 
             if len(memories) < original_count:
                 self._write_json_file(self.memory_table_name, memories)
@@ -477,11 +487,22 @@ class GcsJsonDb(BaseDb):
             log_warning(f"Error deleting user memory: {e}")
             raise e
 
-    def delete_user_memories(self, memory_ids: List[str]) -> None:
-        """Delete multiple user memories from the GCS JSON file."""
+    def delete_user_memories(self, memory_ids: List[str], user_id: Optional[str] = None) -> None:
+        """Delete multiple user memories from the GCS JSON file.
+
+        Args:
+            memory_ids (List[str]): The IDs of the memories to delete.
+            user_id (Optional[str]): The ID of the user. If provided, verifies ownership before deletion.
+        """
         try:
             memories = self._read_json_file(self.memory_table_name)
-            memories = [m for m in memories if m.get("memory_id") not in memory_ids]
+
+            # Filter out memories, with optional user_id verification
+            memories = [
+                m for m in memories
+                if not (m.get("memory_id") in memory_ids and (user_id is None or m.get("user_id") == user_id))
+            ]
+
             self._write_json_file(self.memory_table_name, memories)
             log_debug(f"Successfully deleted user memories with ids: {memory_ids}")
         except Exception as e:
@@ -489,7 +510,11 @@ class GcsJsonDb(BaseDb):
             raise e
 
     def get_all_memory_topics(self) -> List[str]:
-        """Get all memory topics from the GCS JSON file."""
+        """Get all memory topics from the GCS JSON file.
+
+        Returns:
+            List[str]: List of unique memory topics.
+        """
         try:
             memories = self._read_json_file(self.memory_table_name)
             topics = set()
@@ -504,14 +529,27 @@ class GcsJsonDb(BaseDb):
             raise e
 
     def get_user_memory(
-        self, memory_id: str, deserialize: Optional[bool] = True
+        self, memory_id: str, deserialize: Optional[bool] = True, user_id: Optional[str] = None
     ) -> Optional[Union[UserMemory, Dict[str, Any]]]:
-        """Get a memory from the GCS JSON file."""
+        """Get a memory from the GCS JSON file.
+
+        Args:
+            memory_id (str): The ID of the memory to retrieve.
+            deserialize (Optional[bool]): Whether to deserialize to UserMemory object. Defaults to True.
+            user_id (Optional[str]): The ID of the user. If provided, verifies ownership before returning.
+
+        Returns:
+            Optional[Union[UserMemory, Dict[str, Any]]]: The memory if found and ownership matches, None otherwise.
+        """
         try:
             memories = self._read_json_file(self.memory_table_name)
 
             for memory_data in memories:
                 if memory_data.get("memory_id") == memory_id:
+                    # Verify user ownership if user_id is provided
+                    if user_id is not None and memory_data.get("user_id") != user_id:
+                        continue
+
                     if not deserialize:
                         return memory_data
 
@@ -583,20 +621,33 @@ class GcsJsonDb(BaseDb):
     def get_user_memory_stats(
         self, limit: Optional[int] = None, page: Optional[int] = None
     ) -> Tuple[List[Dict[str, Any]], int]:
-        """Get user memory statistics."""
+        """Get user memory statistics.
+
+        Args:
+            limit (Optional[int]): Maximum number of results to return.
+            page (Optional[int]): Page number for pagination.
+
+        Returns:
+            Tuple[List[Dict[str, Any]], int]: List of user memory statistics and total count.
+        """
         try:
             memories = self._read_json_file(self.memory_table_name)
             user_stats = {}
 
             for memory in memories:
-                user_id = memory.get("user_id")
-                if user_id:
-                    if user_id not in user_stats:
-                        user_stats[user_id] = {"user_id": user_id, "total_memories": 0, "last_memory_updated_at": 0}
-                    user_stats[user_id]["total_memories"] += 1
+                memory_user_id = memory.get("user_id")
+
+                if memory_user_id:
+                    if memory_user_id not in user_stats:
+                        user_stats[memory_user_id] = {
+                            "user_id": memory_user_id,
+                            "total_memories": 0,
+                            "last_memory_updated_at": 0
+                        }
+                    user_stats[memory_user_id]["total_memories"] += 1
                     updated_at = memory.get("updated_at", 0)
-                    if updated_at > user_stats[user_id]["last_memory_updated_at"]:
-                        user_stats[user_id]["last_memory_updated_at"] = updated_at
+                    if updated_at > user_stats[memory_user_id]["last_memory_updated_at"]:
+                        user_stats[memory_user_id]["last_memory_updated_at"] = updated_at
 
             stats_list = list(user_stats.values())
             stats_list.sort(key=lambda x: x["last_memory_updated_at"], reverse=True)