agno 2.2.1__py3-none-any.whl → 2.2.3__py3-none-any.whl

agno/culture/manager.py

@@ -78,8 +78,6 @@ class CultureManager:
         self.delete_knowledge = delete_knowledge
         self.clear_knowledge = clear_knowledge
         self.debug_mode = debug_mode
-        self._tools_for_model: Optional[List[Dict[str, Any]]] = None
-        self._functions_for_model: Optional[Dict[str, Function]] = None
 
     def get_model(self) -> Model:
         if self.model is None:
@@ -316,23 +314,27 @@ class CultureManager:
         return response
 
     # -*- Utility Functions -*-
-    def _determine_tools_for_model(self, tools: List[Callable]) -> None:
+    def _determine_tools_for_model(self, tools: List[Callable]) -> List[Union[Function, dict]]:
         # Have to reset each time, because of different user IDs
-        self._tools_for_model = []
-        self._functions_for_model = {}
+
+        _function_names = []
+        _functions: List[Union[Function, dict]] = []
 
         for tool in tools:
             try:
                 function_name = tool.__name__
-                if function_name not in self._functions_for_model:
-                    func = Function.from_callable(tool, strict=True)  # type: ignore
-                    func.strict = True
-                    self._functions_for_model[func.name] = func
-                    self._tools_for_model.append({"type": "function", "function": func.to_dict()})
-                    log_debug(f"Added function {func.name}")
+                if function_name in _function_names:
+                    continue
+                _function_names.append(function_name)
+                func = Function.from_callable(tool, strict=True)  # type: ignore
+                func.strict = True
+                _functions.append(func)
+                log_debug(f"Added function {func.name}")
             except Exception as e:
                 log_warning(f"Could not add function {tool}: {e}")
 
+        return _functions
+
     def get_system_message(
         self,
         existing_knowledge: Optional[List[Dict[str, Any]]] = None,
@@ -460,7 +462,7 @@ class CultureManager:
 
         model_copy = deepcopy(self.model)
         # Update the Model (set defaults, add logit etc.)
-        self._determine_tools_for_model(
+        _tools = self._determine_tools_for_model(
             self._get_db_tools(
                 db,
                 enable_add_knowledge=add_knowledge,
@@ -485,8 +487,7 @@ class CultureManager:
         # Generate a response from the Model (includes running function calls)
         response = model_copy.response(
             messages=messages_for_model,
-            tools=self._tools_for_model,
-            functions=self._functions_for_model,
+            tools=_tools,
         )
 
         if response.tool_calls is not None and len(response.tool_calls) > 0:
@@ -513,7 +514,7 @@ class CultureManager:
         model_copy = deepcopy(self.model)
         db = cast(AsyncBaseDb, db)
 
-        self._determine_tools_for_model(
+        _tools = self._determine_tools_for_model(
             await self._aget_db_tools(
                 db,
                 enable_update_knowledge=update_knowledge,
@@ -535,8 +536,7 @@ class CultureManager:
         # Generate a response from the Model (includes running function calls)
         response = await model_copy.aresponse(
             messages=messages_for_model,
-            tools=self._tools_for_model,
-            functions=self._functions_for_model,
+            tools=_tools,
         )
 
         if response.tool_calls is not None and len(response.tool_calls) > 0:
@@ -564,7 +564,7 @@ class CultureManager:
 
         model_copy = deepcopy(self.model)
         # Update the Model (set defaults, add logit etc.)
-        self._determine_tools_for_model(
+        _tools = self._determine_tools_for_model(
             self._get_db_tools(
                 db,
                 enable_delete_knowledge=delete_knowledge,
@@ -590,8 +590,7 @@ class CultureManager:
         # Generate a response from the Model (includes running function calls)
         response = model_copy.response(
             messages=messages_for_model,
-            tools=self._tools_for_model,
-            functions=self._functions_for_model,
+            tools=_tools,
         )
 
         if response.tool_calls is not None and len(response.tool_calls) > 0:
@@ -620,7 +619,7 @@ class CultureManager:
         model_copy = deepcopy(self.model)
         # Update the Model (set defaults, add logit etc.)
         if isinstance(db, AsyncBaseDb):
-            self._determine_tools_for_model(
+            _tools = self._determine_tools_for_model(
                 await self._aget_db_tools(
                     db,
                     enable_delete_knowledge=delete_knowledge,
@@ -630,7 +629,7 @@ class CultureManager:
                 ),
             )
         else:
-            self._determine_tools_for_model(
+            _tools = self._determine_tools_for_model(
                 self._get_db_tools(
                     db,
                     enable_delete_knowledge=delete_knowledge,
@@ -656,8 +655,7 @@ class CultureManager:
         # Generate a response from the Model (includes running function calls)
         response = await model_copy.aresponse(
             messages=messages_for_model,
-            tools=self._tools_for_model,
-            functions=self._functions_for_model,
+            tools=_tools,
         )
 
         if response.tool_calls is not None and len(response.tool_calls) > 0:

agno/db/async_postgres/__init__.py

@@ -1,3 +1,3 @@
-from agno.db.async_postgres.async_postgres import AsyncPostgresDb
+from agno.db.postgres import AsyncPostgresDb
 
 __all__ = ["AsyncPostgresDb"]

agno/db/dynamo/dynamo.py

@@ -277,8 +277,6 @@ class DynamoDb(BaseDb):
 
             session = deserialize_from_dynamodb_item(item)
 
-            if session.get("session_type") != session_type.value:
-                return None
             if user_id and session.get("user_id") != user_id:
                 return None
 

agno/db/firestore/firestore.py

@@ -280,8 +280,6 @@ class FirestoreDb(BaseDb):
 
             if user_id is not None:
                 query = query.where(filter=FieldFilter("user_id", "==", user_id))
-            if session_type is not None:
-                query = query.where(filter=FieldFilter("session_type", "==", session_type.value))
 
             docs = query.stream()
             result = None

agno/db/gcs_json/gcs_json_db.py

@@ -220,10 +220,6 @@ class GcsJsonDb(BaseDb):
                     if user_id is not None and session_data.get("user_id") != user_id:
                         continue
 
-                    session_type_value = session_type.value if isinstance(session_type, SessionType) else session_type
-                    if session_data.get("session_type") != session_type_value:
-                        continue
-
                     if not deserialize:
                         return session_data
 

agno/db/gcs_json/utils.py

@@ -5,34 +5,10 @@ from datetime import date, datetime, timedelta, timezone
 from typing import Any, Dict, List, Optional
 from uuid import uuid4
 
-from agno.db.base import SessionType
 from agno.db.schemas.culture import CulturalKnowledge
-from agno.run.agent import RunOutput
-from agno.run.team import TeamRunOutput
-from agno.session.summary import SessionSummary
 from agno.utils.log import log_debug
 
 
-def hydrate_session(session: dict) -> dict:
-    """Convert nested dictionaries to their corresponding object types.
-
-    Args:
-        session (dict): The session dictionary to hydrate.
-
-    Returns:
-        dict: The hydrated session dictionary.
-    """
-    if session.get("summary") is not None:
-        session["summary"] = SessionSummary.from_dict(session["summary"])
-    if session.get("runs") is not None:
-        if session["session_type"] == SessionType.AGENT:
-            session["runs"] = [RunOutput.from_dict(run) for run in session["runs"]]
-        elif session["session_type"] == SessionType.TEAM:
-            session["runs"] = [TeamRunOutput.from_dict(run) for run in session["runs"]]
-
-    return session
-
-
 def apply_sorting(
     data: List[Dict[str, Any]], sort_by: Optional[str] = None, sort_order: Optional[str] = None
 ) -> List[Dict[str, Any]]:

agno/db/in_memory/in_memory_db.py

@@ -108,9 +108,6 @@ class InMemoryDb(BaseDb):
                 if session_data.get("session_id") == session_id:
                     if user_id is not None and session_data.get("user_id") != user_id:
                         continue
-                    session_type_value = session_type.value if isinstance(session_type, SessionType) else session_type
-                    if session_data.get("session_type") != session_type_value:
-                        continue
 
                     session_data_copy = deepcopy(session_data)
 

agno/db/json/json_db.py

@@ -13,7 +13,6 @@ from agno.db.json.utils import (
     deserialize_cultural_knowledge_from_db,
     fetch_all_sessions_data,
     get_dates_to_calculate_metrics_for,
-    hydrate_session,
     serialize_cultural_knowledge_for_db,
 )
 from agno.db.schemas.culture import CulturalKnowledge
@@ -202,21 +201,16 @@ class JsonDb(BaseDb):
                 if session_data.get("session_id") == session_id:
                     if user_id is not None and session_data.get("user_id") != user_id:
                         continue
-                    session_type_value = session_type.value if isinstance(session_type, SessionType) else session_type
-                    if session_data.get("session_type") != session_type_value:
-                        continue
-
-                    session = hydrate_session(session_data)
 
                     if not deserialize:
-                        return session
+                        return session_data
 
                     if session_type == SessionType.AGENT:
-                        return AgentSession.from_dict(session)
+                        return AgentSession.from_dict(session_data)
                     elif session_type == SessionType.TEAM:
-                        return TeamSession.from_dict(session)
+                        return TeamSession.from_dict(session_data)
                     elif session_type == SessionType.WORKFLOW:
-                        return WorkflowSession.from_dict(session)
+                        return WorkflowSession.from_dict(session_data)
                     else:
                         raise ValueError(f"Invalid session type: {session_type}")
 

agno/db/json/utils.py

@@ -5,34 +5,10 @@ from datetime import date, datetime, timedelta, timezone
 from typing import Any, Dict, List, Optional
 from uuid import uuid4
 
-from agno.db.base import SessionType
 from agno.db.schemas.culture import CulturalKnowledge
-from agno.run.agent import RunOutput
-from agno.run.team import TeamRunOutput
-from agno.session.summary import SessionSummary
 from agno.utils.log import log_debug
 
 
-def hydrate_session(session: dict) -> dict:
-    """Convert nested dictionaries to their corresponding object types.
-
-    Args:
-        session (dict): The session dictionary to hydrate.
-
-    Returns:
-        dict: The hydrated session dictionary.
-    """
-    if session.get("summary") is not None:
-        session["summary"] = SessionSummary.from_dict(session["summary"])
-    if session.get("runs") is not None:
-        if session["session_type"] == SessionType.AGENT:
-            session["runs"] = [RunOutput.from_dict(run) for run in session["runs"]]
-        elif session["session_type"] == SessionType.TEAM:
-            session["runs"] = [TeamRunOutput.from_dict(run) for run in session["runs"]]
-
-    return session
-
-
 def apply_sorting(
     data: List[Dict[str, Any]], sort_by: Optional[str] = None, sort_order: Optional[str] = None
 ) -> List[Dict[str, Any]]:

agno/db/mongo/__init__.py

@@ -1,3 +1,17 @@
+from typing import TYPE_CHECKING
+
 from agno.db.mongo.mongo import MongoDb
 
-__all__ = ["MongoDb"]
+if TYPE_CHECKING:
+    from agno.db.mongo.async_mongo import AsyncMongoDb
+
+__all__ = ["AsyncMongoDb", "MongoDb"]
+
+
+def __getattr__(name: str):
+    """Lazy import AsyncMongoDb only when accessed."""
+    if name == "AsyncMongoDb":
+        from agno.db.mongo.async_mongo import AsyncMongoDb
+
+        return AsyncMongoDb
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")