agno 2.2.2__py3-none-any.whl → 2.2.4__py3-none-any.whl

agno/db/mongo/utils.py

@@ -117,7 +117,7 @@ def calculate_date_metrics(date_to_process: date, sessions_data: dict) -> dict:
 
     model_metrics = []
     for model, count in model_counts.items():
-        model_id, model_provider = model.split(":")
+        model_id, model_provider = model.rsplit(":", 1)
         model_metrics.append({"model_id": model_id, "model_provider": model_provider, "count": count})
 
     metrics["users_count"] = len(all_user_ids)

agno/db/mysql/utils.py

@@ -226,7 +226,7 @@ def calculate_date_metrics(date_to_process: date, sessions_data: dict) -> dict:
 
     model_metrics = []
     for model, count in model_counts.items():
-        model_id, model_provider = model.split(":")
+        model_id, model_provider = model.rsplit(":", 1)
         model_metrics.append({"model_id": model_id, "model_provider": model_provider, "count": count})
 
     metrics["users_count"] = len(all_user_ids)

agno/db/postgres/async_postgres.py

@@ -37,7 +37,7 @@ except ImportError:
 class AsyncPostgresDb(AsyncBaseDb):
     def __init__(
         self,
-        db_id: Optional[str] = None,
+        id: Optional[str] = None,
         db_url: Optional[str] = None,
         db_engine: Optional[AsyncEngine] = None,
         db_schema: Optional[str] = None,
@@ -47,6 +47,7 @@ class AsyncPostgresDb(AsyncBaseDb):
         eval_table: Optional[str] = None,
         knowledge_table: Optional[str] = None,
         culture_table: Optional[str] = None,
+        db_id: Optional[str] = None,  # Deprecated, use id instead.
     ):
         """
         Async interface for interacting with a PostgreSQL database.
@@ -57,7 +58,7 @@ class AsyncPostgresDb(AsyncBaseDb):
             3. Raise an error if neither is provided
 
         Args:
-            db_id (Optional[str]): The ID of the database.
+            id (Optional[str]): The ID of the database.
             db_url (Optional[str]): The database URL to connect to.
             db_engine (Optional[AsyncEngine]): The SQLAlchemy async database engine to use.
             db_schema (Optional[str]): The database schema to use.
@@ -67,13 +68,17 @@ class AsyncPostgresDb(AsyncBaseDb):
             eval_table (Optional[str]): Name of the table to store evaluation runs data.
             knowledge_table (Optional[str]): Name of the table to store knowledge content.
             culture_table (Optional[str]): Name of the table to store cultural knowledge.
+            db_id: Deprecated, use id instead.
 
         Raises:
             ValueError: If neither db_url nor db_engine is provided.
             ValueError: If none of the tables are provided.
         """
+        if db_id is not None:
+            log_warning("db_id is deprecated and will be removed in a future version, use id instead.")
+
         super().__init__(
-            id=db_id,
+            id=id or db_id,
             session_table=session_table,
             memory_table=memory_table,
             metrics_table=metrics_table,

agno/db/postgres/utils.py

@@ -313,7 +313,7 @@ def calculate_date_metrics(date_to_process: date, sessions_data: dict) -> dict:
 
     model_metrics = []
     for model, count in model_counts.items():
-        model_id, model_provider = model.split(":")
+        model_id, model_provider = model.rsplit(":", 1)
         model_metrics.append({"model_id": model_id, "model_provider": model_provider, "count": count})
 
     metrics["users_count"] = len(all_user_ids)

agno/db/redis/utils.py

@@ -221,7 +221,7 @@ def calculate_date_metrics(date_to_process: date, sessions_data: dict) -> dict:
 
     model_metrics = []
     for model, count in model_counts.items():
-        model_id, model_provider = model.split(":")
+        model_id, model_provider = model.rsplit(":", 1)
         model_metrics.append({"model_id": model_id, "model_provider": model_provider, "count": count})
 
     metrics["users_count"] = len(all_user_ids)

agno/db/singlestore/utils.py

@@ -255,7 +255,7 @@ def calculate_date_metrics(date_to_process: date, sessions_data: dict) -> dict:
 
     model_metrics = []
     for model, count in model_counts.items():
-        model_id, model_provider = model.split(":")
+        model_id, model_provider = model.rsplit(":", 1)
         model_metrics.append({"model_id": model_id, "model_provider": model_provider, "count": count})
 
     metrics["users_count"] = len(all_user_ids)

agno/db/sqlite/utils.py

@@ -298,7 +298,7 @@ def calculate_date_metrics(date_to_process: date, sessions_data: dict) -> dict:
 
     model_metrics = []
     for model, count in model_counts.items():
-        model_id, model_provider = model.split(":")
+        model_id, model_provider = model.rsplit(":", 1)
         model_metrics.append({"model_id": model_id, "model_provider": model_provider, "count": count})
 
     metrics["users_count"] = len(all_user_ids)

agno/knowledge/embedder/ollama.py

@@ -85,6 +85,10 @@ class OllamaEmbedder(Embedder):
         if self.options is not None:
             kwargs["options"] = self.options
 
+        # Add dimensions parameter for models that support it
+        if self.dimensions is not None:
+            kwargs["dimensions"] = self.dimensions
+
         response = self.client.embed(input=text, model=self.id, **kwargs)
         if response and "embeddings" in response:
             embeddings = response["embeddings"]
@@ -117,6 +121,10 @@ class OllamaEmbedder(Embedder):
         if self.options is not None:
             kwargs["options"] = self.options
 
+        # Add dimensions parameter for models that support it
+        if self.dimensions is not None:
+            kwargs["dimensions"] = self.dimensions
+
         response = await self.aclient.embed(input=text, model=self.id, **kwargs)
         if response and "embeddings" in response:
             embeddings = response["embeddings"]

agno/memory/manager.py

@@ -843,7 +843,7 @@ class MemoryManager:
                 team_id=team_id,
                 enable_add_memory=add_memories,
                 enable_update_memory=update_memories,
-                enable_delete_memory=False,
+                enable_delete_memory=True,
                 enable_clear_memory=False,
             ),
         )
@@ -854,7 +854,7 @@ class MemoryManager:
                 existing_memories=existing_memories,
                 enable_update_memory=update_memories,
                 enable_add_memory=add_memories,
-                enable_delete_memory=False,
+                enable_delete_memory=True,
                 enable_clear_memory=False,
             ),
             *messages,
@@ -906,7 +906,7 @@ class MemoryManager:
                     team_id=team_id,
                     enable_add_memory=add_memories,
                     enable_update_memory=update_memories,
-                    enable_delete_memory=False,
+                    enable_delete_memory=True,
                     enable_clear_memory=False,
                 ),
             )
@@ -920,7 +920,7 @@ class MemoryManager:
                     team_id=team_id,
                     enable_add_memory=add_memories,
                     enable_update_memory=update_memories,
-                    enable_delete_memory=False,
+                    enable_delete_memory=True,
                     enable_clear_memory=False,
                 ),
             )
@@ -931,7 +931,7 @@ class MemoryManager:
                 existing_memories=existing_memories,
                 enable_update_memory=update_memories,
                 enable_add_memory=add_memories,
-                enable_delete_memory=False,
+                enable_delete_memory=True,
                 enable_clear_memory=False,
             ),
             *messages,

agno/os/app.py

@@ -187,54 +187,50 @@ class AgentOS:
         self.mcp_tools: List[Any] = []
         self._mcp_app: Optional[Any] = None
 
-        if self.agents:
-            for agent in self.agents:
-                # Track all MCP tools to later handle their connection
-                if agent.tools:
-                    for tool in agent.tools:
-                        # Checking if the tool is a MCPTools or MultiMCPTools instance
-                        type_name = type(tool).__name__
-                        if type_name in ("MCPTools", "MultiMCPTools"):
-                            if tool not in self.mcp_tools:
-                                self.mcp_tools.append(tool)
-
-                agent.initialize_agent()
+        self._initialize_agents()
+        self._initialize_teams()
+        self._initialize_workflows()
 
-                # Required for the built-in routes to work
-                agent.store_events = True
-
-        if self.teams:
-            for team in self.teams:
-                # Track all MCP tools recursively
-                collect_mcp_tools_from_team(team, self.mcp_tools)
+        if self.telemetry:
+            from agno.api.os import OSLaunch, log_os_telemetry
 
-                team.initialize_team()
+            log_os_telemetry(launch=OSLaunch(os_id=self.id, data=self._get_telemetry_data()))
 
-                for member in team.members:
-                    if isinstance(member, Agent):
-                        member.team_id = None
-                        member.initialize_agent()
-                    elif isinstance(member, Team):
-                        member.initialize_team()
+    def _add_agent_os_to_lifespan_function(self, lifespan):
+        """
+        Inspect a lifespan function and wrap it to pass agent_os if it accepts it.
 
-                # Required for the built-in routes to work
-                team.store_events = True
+        Returns:
+            A wrapped lifespan that passes agent_os if the lifespan function expects it.
+        """
+        # Getting the actual function inside the lifespan
+        lifespan_function = lifespan
+        if hasattr(lifespan, "__wrapped__"):
+            lifespan_function = lifespan.__wrapped__
 
-        if self.workflows:
-            for workflow in self.workflows:
-                # Track MCP tools recursively in workflow members
-                collect_mcp_tools_from_workflow(workflow, self.mcp_tools)
+        try:
+            from inspect import signature
 
-                if not workflow.id:
-                    workflow.id = generate_id_from_name(workflow.name)
+            # Inspecting the lifespan function signature to find its parameters
+            sig = signature(lifespan_function)
+            params = list(sig.parameters.keys())
 
-                # Required for the built-in routes to work
-                workflow.store_events = True
+            # If the lifespan function expects the 'agent_os' parameter, add it
+            if "agent_os" in params:
+                return partial(lifespan, agent_os=self)
+            else:
+                return lifespan
 
-        if self.telemetry:
-            from agno.api.os import OSLaunch, log_os_telemetry
+        except (ValueError, TypeError):
+            return lifespan
 
-            log_os_telemetry(launch=OSLaunch(os_id=self.id, data=self._get_telemetry_data()))
+    def resync(self) -> None:
+        """Resync the AgentOS to discover, initialize and configure: agents, teams, workflows, databases and knowledge bases."""
+        self._initialize_agents()
+        self._initialize_teams()
+        self._initialize_workflows()
+        self._auto_discover_databases()
+        self._auto_discover_knowledge_instances()
 
     def _make_app(self, lifespan: Optional[Any] = None) -> FastAPI:
         # Adjust the FastAPI app lifespan to handle MCP connections if relevant
@@ -265,6 +261,63 @@ class AgentOS:
             lifespan=app_lifespan,
         )
 
+    def _initialize_agents(self) -> None:
+        """Initialize and configure all agents for AgentOS usage."""
+        if not self.agents:
+            return
+
+        for agent in self.agents:
+            # Track all MCP tools to later handle their connection
+            if agent.tools:
+                for tool in agent.tools:
+                    # Checking if the tool is a MCPTools or MultiMCPTools instance
+                    type_name = type(tool).__name__
+                    if type_name in ("MCPTools", "MultiMCPTools"):
+                        if tool not in self.mcp_tools:
+                            self.mcp_tools.append(tool)
+
+            agent.initialize_agent()
+
+            # Required for the built-in routes to work
+            agent.store_events = True
+
+    def _initialize_teams(self) -> None:
+        """Initialize and configure all teams for AgentOS usage."""
+        if not self.teams:
+            return
+
+        for team in self.teams:
+            # Track all MCP tools recursively
+            collect_mcp_tools_from_team(team, self.mcp_tools)
+
+            team.initialize_team()
+
+            for member in team.members:
+                if isinstance(member, Agent):
+                    member.team_id = None
+                    member.initialize_agent()
+                elif isinstance(member, Team):
+                    member.initialize_team()
+
+            # Required for the built-in routes to work
+            team.store_events = True
+
+    def _initialize_workflows(self) -> None:
+        """Initialize and configure all workflows for AgentOS usage."""
+        if not self.workflows:
+            return
+
+        if self.workflows:
+            for workflow in self.workflows:
+                # Track MCP tools recursively in workflow members
+                collect_mcp_tools_from_workflow(workflow, self.mcp_tools)
+
+                if not workflow.id:
+                    workflow.id = generate_id_from_name(workflow.name)
+
+                # Required for the built-in routes to work
+                workflow.store_events = True
+
     def get_app(self) -> FastAPI:
         if self.base_app:
             fastapi_app = self.base_app
@@ -288,7 +341,9 @@ class AgentOS:
                 lifespans.append(self._mcp_app.lifespan)
 
             if self.lifespan:
-                lifespans.append(self.lifespan)
+                # Wrap the user lifespan with agent_os parameter
+                wrapped_lifespan = self._add_agent_os_to_lifespan_function(self.lifespan)
+                lifespans.append(wrapped_lifespan)
 
             # Combine lifespans and set them in the app
             if lifespans:
@@ -304,11 +359,14 @@ class AgentOS:
 
                 final_lifespan = self._mcp_app.lifespan  # type: ignore
                 if self.lifespan is not None:
+                    # Wrap the user lifespan with agent_os parameter
+                    wrapped_lifespan = self._add_agent_os_to_lifespan_function(self.lifespan)
+
                     # Combine both lifespans
                     @asynccontextmanager
                     async def combined_lifespan(app: FastAPI):
                         # Run both lifespans
-                        async with self.lifespan(app):  # type: ignore
+                        async with wrapped_lifespan(app):  # type: ignore
                             async with self._mcp_app.lifespan(app):  # type: ignore
                                 yield
 
@@ -316,7 +374,12 @@ class AgentOS:
 
                 fastapi_app = self._make_app(lifespan=final_lifespan)
             else:
-                fastapi_app = self._make_app(lifespan=self.lifespan)
+                # Wrap the user lifespan with agent_os parameter
+                wrapped_user_lifespan = None
+                if self.lifespan is not None:
+                    wrapped_user_lifespan = self._add_agent_os_to_lifespan_function(self.lifespan)
+
+                fastapi_app = self._make_app(lifespan=wrapped_user_lifespan)
 
         # Add routes
         self._add_router(fastapi_app, get_base_router(self, settings=self.settings))

agno/os/schema.py

@@ -475,7 +475,6 @@ class TeamResponse(BaseModel):
             team_run_context={},
             check_mcp_tools=False,
         )
-        print(team.tools, _tools)
         team_tools = _tools
         formatted_tools = format_team_tools(team_tools) if team_tools else None
 

agno/run/agent.py

@@ -70,12 +70,39 @@ class RunInput:
                 result["input_content"] = self.input_content.model_dump(exclude_none=True)
             elif isinstance(self.input_content, Message):
                 result["input_content"] = self.input_content.to_dict()
+
+            # Handle input_content provided as a list of Message objects
             elif (
                 isinstance(self.input_content, list)
                 and self.input_content
                 and isinstance(self.input_content[0], Message)
             ):
                 result["input_content"] = [m.to_dict() for m in self.input_content]
+
+            # Handle input_content provided as a list of dicts
+            elif (
+                isinstance(self.input_content, list) and self.input_content and isinstance(self.input_content[0], dict)
+            ):
+                for content in self.input_content:
+                    # Handle media input
+                    if isinstance(content, dict):
+                        if content.get("images"):
+                            content["images"] = [
+                                img.to_dict() if isinstance(img, Image) else img for img in content["images"]
+                            ]
+                        if content.get("videos"):
+                            content["videos"] = [
+                                vid.to_dict() if isinstance(vid, Video) else vid for vid in content["videos"]
+                            ]
+                        if content.get("audios"):
+                            content["audios"] = [
+                                aud.to_dict() if isinstance(aud, Audio) else aud for aud in content["audios"]
+                            ]
+                        if content.get("files"):
+                            content["files"] = [
+                                file.to_dict() if isinstance(file, File) else file for file in content["files"]
+                            ]
+                result["input_content"] = self.input_content
             else:
                 result["input_content"] = self.input_content
 

agno/run/team.py

@@ -66,12 +66,39 @@ class TeamRunInput:
                 result["input_content"] = self.input_content.model_dump(exclude_none=True)
             elif isinstance(self.input_content, Message):
                 result["input_content"] = self.input_content.to_dict()
+
+            # Handle input_content provided as a list of Message objects
             elif (
                 isinstance(self.input_content, list)
                 and self.input_content
                 and isinstance(self.input_content[0], Message)
             ):
                 result["input_content"] = [m.to_dict() for m in self.input_content]
+
+            # Handle input_content provided as a list of dicts
+            elif (
+                isinstance(self.input_content, list) and self.input_content and isinstance(self.input_content[0], dict)
+            ):
+                for content in self.input_content:
+                    # Handle media input
+                    if isinstance(content, dict):
+                        if content.get("images"):
+                            content["images"] = [
+                                img.to_dict() if isinstance(img, Image) else img for img in content["images"]
+                            ]
+                        if content.get("videos"):
+                            content["videos"] = [
+                                vid.to_dict() if isinstance(vid, Video) else vid for vid in content["videos"]
+                            ]
+                        if content.get("audios"):
+                            content["audios"] = [
+                                aud.to_dict() if isinstance(aud, Audio) else aud for aud in content["audios"]
+                            ]
+                        if content.get("files"):
+                            content["files"] = [
+                                file.to_dict() if isinstance(file, File) else file for file in content["files"]
+                            ]
+                result["input_content"] = self.input_content
             else:
                 result["input_content"] = self.input_content
 

agno/session/agent.py

@@ -107,11 +107,25 @@ class AgentSession:
                 return run
         return None
 
+    def _should_skip_message(
+        self, message: Message, skip_role: Optional[str] = None, skip_history_messages: bool = True
+    ) -> bool:
+        """Processes a message for history"""
+        # Skip messages that were tagged as history in previous runs
+        if hasattr(message, "from_history") and message.from_history and skip_history_messages:
+            return True
+
+        # Skip messages with specified role
+        if skip_role and message.role == skip_role:
+            return True
+        return False
+
     def get_messages_from_last_n_runs(
         self,
         agent_id: Optional[str] = None,
         team_id: Optional[str] = None,
         last_n: Optional[int] = None,
+        last_n_messages: Optional[int] = None,
         skip_role: Optional[str] = None,
         skip_status: Optional[List[RunStatus]] = None,
         skip_history_messages: bool = True,
@@ -121,6 +135,7 @@ class AgentSession:
             agent_id: The id of the agent to get the messages from.
             team_id: The id of the team to get the messages from.
             last_n: The number of runs to return from the end of the conversation. Defaults to all runs.
+            last_n_messages: The number of messages to return from the end of the conversation. Defaults to all messages.
             skip_role: Skip messages with this role.
             skip_status: Skip messages with this status.
             skip_history_messages: Skip messages that were tagged as history in previous runs.
@@ -146,30 +161,55 @@ class AgentSession:
         # Filter by status
         session_runs = [run for run in session_runs if hasattr(run, "status") and run.status not in skip_status]  # type: ignore
 
-        # Filter by last_n
-        runs_to_process = session_runs[-last_n:] if last_n is not None else session_runs
         messages_from_history = []
         system_message = None
-        for run_response in runs_to_process:
-            if not (run_response and run_response.messages):
-                continue
 
-            for message in run_response.messages or []:
-                # Skip messages that were tagged as history in previous runs
-                if hasattr(message, "from_history") and message.from_history and skip_history_messages:
+        # Filter by last_n_messages
+        if last_n_messages is not None:
+            for run_response in session_runs:
+                if not run_response or not run_response.messages:
                     continue
 
-                # Skip messages with specified role
-                if skip_role and message.role == skip_role:
+                for message in run_response.messages or []:
+                    if self._should_skip_message(message, skip_role, skip_history_messages):
+                        continue
+
+                    if message.role == "system":
+                        # Only add the system message once
+                        if system_message is None:
+                            system_message = message
+                    else:
+                        messages_from_history.append(message)
+
+            if system_message:
+                messages_from_history = [system_message] + messages_from_history[
+                    -(last_n_messages - 1) :
+                ]  # Grab one less message then add the system message
+            else:
+                messages_from_history = messages_from_history[-last_n_messages:]
+
+            # Remove tool result messages that don't have an associated assistant message with tool calls
+            while len(messages_from_history) > 0 and messages_from_history[0].role == "tool":
+                messages_from_history.pop(0)
+
+        else:
+            # Filter by last_n runs
+            runs_to_process = session_runs[-last_n:] if last_n is not None else session_runs
+            for run_response in runs_to_process:
+                if not run_response or not run_response.messages:
                     continue
 
-                if message.role == "system":
-                    # Only add the system message once
-                    if system_message is None:
-                        system_message = message
-                        messages_from_history.append(system_message)
-                else:
-                    messages_from_history.append(message)
+                for message in run_response.messages or []:
+                    if self._should_skip_message(message, skip_role, skip_history_messages):
+                        continue
+
+                    if message.role == "system":
+                        # Only add the system message once
+                        if system_message is None:
+                            system_message = message
+                            messages_from_history.append(system_message)
+                    else:
+                        messages_from_history.append(message)
 
         log_debug(f"Getting messages from previous runs: {len(messages_from_history)}")
         return messages_from_history