agno 2.2.13__py3-none-any.whl → 2.3.1__py3-none-any.whl

agno/os/router.py

@@ -13,9 +13,12 @@ from fastapi import (
     WebSocket,
 )
 from fastapi.responses import JSONResponse, StreamingResponse
+from packaging import version
 from pydantic import BaseModel
 
 from agno.agent.agent import Agent
+from agno.db.base import AsyncBaseDb
+from agno.db.migrations.manager import MigrationManager
 from agno.exceptions import InputCheckError, OutputCheckError
 from agno.media import Audio, Image, Video
 from agno.media import File as FileMedia
@@ -39,6 +42,7 @@ from agno.os.schema import (
 from agno.os.settings import AgnoAPISettings
 from agno.os.utils import (
     get_agent_by_id,
+    get_db,
     get_team_by_id,
     get_workflow_by_id,
     process_audio,
@@ -1760,4 +1764,54 @@ def get_base_router(
 
         return JSONResponse(content={}, status_code=200)
 
+    # -- Database Migration routes ---
+
+    @router.post(
+        "/databases/{db_id}/migrate",
+        tags=["Database"],
+        operation_id="migrate_database",
+        summary="Migrate Database",
+        description=(
+            "Migrate the given database schema to the given target version. "
+            "If a target version is not provided, the database will be migrated to the latest version. "
+        ),
+        responses={
+            200: {
+                "description": "Database migrated successfully",
+                "content": {
+                    "application/json": {
+                        "example": {"message": "Database migrated successfully to version 3.0.0"},
+                    }
+                },
+            },
+            404: {"description": "Database not found", "model": NotFoundResponse},
+            500: {"description": "Failed to migrate database", "model": InternalServerErrorResponse},
+        },
+    )
+    async def migrate_database(db_id: str, target_version: Optional[str] = None):
+        db = await get_db(os.dbs, db_id)
+        if not db:
+            raise HTTPException(status_code=404, detail="Database not found")
+
+        if target_version:
+            
+            # Use the session table as proxy for the database schema version
+            if isinstance(db, AsyncBaseDb):
+                current_version = await db.get_latest_schema_version(db.session_table_name)
+            else:
+                current_version = db.get_latest_schema_version(db.session_table_name)
+
+            if version.parse(target_version) > version.parse(current_version):  # type: ignore
+                MigrationManager(db).up(target_version)  # type: ignore
+            else:
+                MigrationManager(db).down(target_version)  # type: ignore
+
+        # If the target version is not provided, migrate to the latest version
+        else:
+            MigrationManager(db).up()  # type: ignore
+
+        return JSONResponse(
+            content={"message": f"Database migrated successfully to version {target_version}"}, status_code=200
+        )
+
     return router

agno/os/routers/knowledge/knowledge.py

@@ -617,7 +617,7 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         "/knowledge/config",
         status_code=200,
         operation_id="get_knowledge_config",
-        summary="Get Knowledge Configuration",
+        summary="Get Config",
         description=(
             "Retrieve available readers, chunkers, and configuration options for content processing. "
             "This endpoint provides metadata about supported file types, processing strategies, and filters."
@@ -942,7 +942,7 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             vector_dbs=vector_dbs,
             readersForType=types_of_readers,
             chunkers=chunkers_dict,
-            filters=knowledge.get_filters(),
+            filters=knowledge.get_valid_filters(),
         )
 
     return router

agno/os/schema.py

@@ -458,7 +458,7 @@ class TeamResponse(BaseModel):
             "reasoning_max_steps": 10,
             # Default tools defaults
             "search_knowledge": True,
-            "read_team_history": False,
+            "read_chat_history": False,
             "get_member_information_tool": False,
             # System message defaults
             "system_message_role": "system",
@@ -556,7 +556,7 @@ class TeamResponse(BaseModel):
 
         default_tools_info = {
             "search_knowledge": team.search_knowledge,
-            "read_team_history": team.read_team_history,
+            "read_chat_history": team.read_chat_history,
             "get_member_information_tool": team.get_member_information_tool,
         }
 

agno/session/agent.py

@@ -112,71 +112,76 @@ 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(
+    def get_messages(
         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,
+        last_n_runs: Optional[int] = None,
+        limit: Optional[int] = None,
+        skip_roles: Optional[List[str]] = None,
+        skip_statuses: Optional[List[RunStatus]] = None,
         skip_history_messages: bool = True,
     ) -> List[Message]:
-        """Returns the messages from the last_n runs, excluding previously tagged history messages.
+        """Returns the messages belonging to the session that fit the given criteria.
+
         Args:
             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.
+            last_n_runs: The number of runs to return messages from, counting from the latest. Defaults to all runs.
+            last_n_messages: The number of messages to return, counting from the latest. Defaults to all messages.
+            skip_roles: Skip messages with these roles.
+            skip_statuses: Skip messages with these statuses.
             skip_history_messages: Skip messages that were tagged as history in previous runs.
+
         Returns:
-            A list of Messages from the specified runs, excluding history messages.
+            A list of Messages belonging to the session.
         """
+
+        def _should_skip_message(
+            message: Message, skip_roles: Optional[List[str]] = None, skip_history_messages: bool = True
+        ) -> bool:
+            """Logic to determine if a message should be skipped"""
+            # 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_roles and message.role in skip_roles:
+                return True
+
+            return False
+
         if not self.runs:
             return []
 
-        if skip_status is None:
-            skip_status = [RunStatus.paused, RunStatus.cancelled, RunStatus.error]
+        if skip_statuses is None:
+            skip_statuses = [RunStatus.paused, RunStatus.cancelled, RunStatus.error]
+
+        runs = self.runs
 
-        session_runs = self.runs
         # Filter by agent_id and team_id
         if agent_id:
-            session_runs = [run for run in session_runs if hasattr(run, "agent_id") and run.agent_id == agent_id]  # type: ignore
+            runs = [run for run in runs if hasattr(run, "agent_id") and run.agent_id == agent_id]  # type: ignore
         if team_id:
-            session_runs = [run for run in session_runs if hasattr(run, "team_id") and run.team_id == team_id]  # type: ignore
+            runs = [run for run in runs if hasattr(run, "team_id") and run.team_id == team_id]  # type: ignore
 
         # Skip any messages that might be part of members of teams (for session re-use)
-        session_runs = [run for run in session_runs if run.parent_run_id is None]  # type: ignore
+        runs = [run for run in runs if run.parent_run_id is None]  # type: ignore
 
         # Filter by status
-        session_runs = [run for run in session_runs if hasattr(run, "status") and run.status not in skip_status]  # type: ignore
+        runs = [run for run in runs if hasattr(run, "status") and run.status not in skip_statuses]  # type: ignore
 
         messages_from_history = []
         system_message = None
 
-        # Filter by last_n_messages
-        if last_n_messages is not None:
-            for run_response in session_runs:
+        # Limit the number of messages returned if limit is set
+        if limit is not None:
+            for run_response in runs:
                 if not run_response or not run_response.messages:
                     continue
 
                 for message in run_response.messages or []:
-                    if self._should_skip_message(message, skip_role, skip_history_messages):
+                    if _should_skip_message(message, skip_roles, skip_history_messages):
                         continue
 
                     if message.role == "system":
@@ -188,24 +193,24 @@ class AgentSession:
 
             if system_message:
                 messages_from_history = [system_message] + messages_from_history[
-                    -(last_n_messages - 1) :
+                    -(limit - 1) :
                 ]  # Grab one less message then add the system message
             else:
-                messages_from_history = messages_from_history[-last_n_messages:]
+                messages_from_history = messages_from_history[-limit:]
 
             # 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)
 
+        # If limit is not set, return all messages
         else:
-            # Filter by last_n runs
-            runs_to_process = session_runs[-last_n:] if last_n is not None else session_runs
+            runs_to_process = runs[-last_n_runs:] if last_n_runs is not None else runs
             for run_response in runs_to_process:
                 if not run_response or not run_response.messages:
                     continue
 
                 for message in run_response.messages or []:
-                    if self._should_skip_message(message, skip_role, skip_history_messages):
+                    if _should_skip_message(message, skip_roles, skip_history_messages):
                         continue
 
                     if message.role == "system":
@@ -219,6 +224,18 @@ class AgentSession:
         log_debug(f"Getting messages from previous runs: {len(messages_from_history)}")
         return messages_from_history
 
+    def get_chat_history(self, last_n_runs: Optional[int] = None) -> List[Message]:
+        """Return the chat history (user and assistant messages) for the session.
+        Use get_messages() for more filtering options.
+
+        Args:
+            last_n_runs: Number of recent runs to include. If None, all runs will be considered.
+
+        Returns:
+            A list of user and assistant Messages belonging to the session.
+        """
+        return self.get_messages(skip_roles=["system", "tool"], last_n_runs=last_n_runs)
+
     def get_tool_calls(self, num_calls: Optional[int] = None) -> List[Dict[str, Any]]:
         """Returns a list of tool calls from the messages"""
 
@@ -235,61 +252,9 @@ class AgentSession:
                                     return tool_calls
         return tool_calls
 
-    def get_messages_for_session(
-        self,
-        user_role: str = "user",
-        assistant_role: Optional[List[str]] = None,
-        skip_history_messages: bool = True,
-    ) -> List[Message]:
-        """Returns a list of messages for the session that iterate through user message and assistant response."""
-
-        if assistant_role is None:
-            # TODO: Check if we still need CHATBOT as a role
-            assistant_role = ["assistant", "model", "CHATBOT"]
-
-        final_messages: List[Message] = []
-        session_runs = self.runs
-        if not session_runs:
-            return []
-
-        for run_response in session_runs:
-            if run_response and run_response.messages:
-                user_message_from_run = None
-                assistant_message_from_run = None
-
-                # Start from the beginning to look for the user message
-                for message in run_response.messages or []:
-                    if hasattr(message, "from_history") and message.from_history and skip_history_messages:
-                        continue
-                    if message.role == user_role:
-                        user_message_from_run = message
-                        break
-
-                # Start from the end to look for the assistant response
-                for message in run_response.messages[::-1]:
-                    if hasattr(message, "from_history") and message.from_history and skip_history_messages:
-                        continue
-                    if message.role in assistant_role:
-                        assistant_message_from_run = message
-                        break
-
-                if user_message_from_run and assistant_message_from_run:
-                    final_messages.append(user_message_from_run)
-                    final_messages.append(assistant_message_from_run)
-        return final_messages
-
     def get_session_summary(self) -> Optional[SessionSummary]:
         """Get the session summary for the session"""
 
         if self.summary is None:
             return None
         return self.summary
-
-    # Chat History functions
-    def get_chat_history(self) -> List[Message]:
-        """Get the chat history for the session"""
-
-        messages = []
-        for run in self.runs or []:
-            messages.extend([msg for msg in run.messages or [] if not msg.from_history])
-        return messages

agno/session/summary.py

@@ -150,7 +150,7 @@ class SessionSummaryManager:
         response_format = self.get_response_format(self.model)
 
         system_message = self.get_system_message(
-            conversation=session.get_messages_for_session(),  # type: ignore
+            conversation=session.get_messages(),  # type: ignore
             response_format=response_format,
         )
 

agno/session/team.py

@@ -113,74 +113,82 @@ class TeamSession:
 
         log_debug("Added RunOutput to Team Session")
 
-    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(
+    def get_messages(
         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,
+        member_ids: Optional[List[str]] = None,
+        last_n_runs: Optional[int] = None,
+        limit: Optional[int] = None,
+        skip_roles: Optional[List[str]] = None,
+        skip_statuses: Optional[List[RunStatus]] = None,
         skip_history_messages: bool = True,
-        member_runs: bool = False,
+        skip_member_messages: bool = True,
     ) -> List[Message]:
-        """Returns the messages from the last_n runs, excluding previously tagged history messages.
-        Args:
+        """Returns the messages belonging to the session that fit the given criteria.
 
-            agent_id: The id of the agent to get the messages from.
+        Args:
             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.
+            member_ids: The ids of the members to get the messages from.
+            last_n_runs: The number of runs to return messages from, counting from the latest. Defaults to all runs.
+            limit: The number of messages to return, counting from the latest. Defaults to all messages.
+            skip_roles: Skip messages with these roles.
+            skip_statuses: Skip messages with these statuses.
             skip_history_messages: Skip messages that were tagged as history in previous runs.
+            skip_member_messages: Skip messages created by members of the team.
+
         Returns:
-            A list of Messages from the specified runs, excluding history messages.
+            A list of Messages belonging to the session.
         """
+
+        def _should_skip_message(
+            message: Message, skip_roles: Optional[List[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_roles and message.role in skip_roles:
+                return True
+            return False
+
+        if member_ids is not None and skip_member_messages:
+            log_debug("Member IDs to filter by were provided. The skip_member_messages flag will be ignored.")
+            skip_member_messages = False
+
         if not self.runs:
             return []
 
-        if skip_status is None:
-            skip_status = [RunStatus.paused, RunStatus.cancelled, RunStatus.error]
+        if skip_statuses is None:
+            skip_statuses = [RunStatus.paused, RunStatus.cancelled, RunStatus.error]
 
         session_runs = self.runs
 
-        # Filter by agent_id and team_id
-        if agent_id:
-            session_runs = [run for run in session_runs if hasattr(run, "agent_id") and run.agent_id == agent_id]  # type: ignore
+        # Filter by team_id and member_ids
         if team_id:
             session_runs = [run for run in session_runs if hasattr(run, "team_id") and run.team_id == team_id]  # type: ignore
+        if member_ids:
+            session_runs = [run for run in session_runs if hasattr(run, "agent_id") and run.agent_id in member_ids]  # type: ignore
 
-        if not member_runs:
+        if skip_member_messages:
             # Filter for the top-level runs (main team runs or agent runs when sharing session)
             session_runs = [run for run in session_runs if run.parent_run_id is None]  # type: ignore
+
         # Filter by status
-        session_runs = [run for run in session_runs if hasattr(run, "status") and run.status not in skip_status]  # type: ignore
+        session_runs = [run for run in session_runs if hasattr(run, "status") and run.status not in skip_statuses]  # type: ignore
 
         messages_from_history = []
         system_message = None
 
-        # Filter by last_n_messages
-        if last_n_messages is not None:
+        # Limit the number of messages returned if limit is set
+        if limit is not None:
             for run_response in session_runs:
                 if not run_response or not run_response.messages:
                     continue
 
                 for message in run_response.messages or []:
-                    if self._should_skip_message(message, skip_role, skip_history_messages):
+                    if _should_skip_message(message, skip_roles, skip_history_messages):
                         continue
 
                     if message.role == "system":
@@ -192,24 +200,24 @@ class TeamSession:
 
             if system_message:
                 messages_from_history = [system_message] + messages_from_history[
-                    -(last_n_messages - 1) :
+                    -(limit - 1) :
                 ]  # Grab one less message then add the system message
             else:
-                messages_from_history = messages_from_history[-last_n_messages:]
+                messages_from_history = messages_from_history[-limit:]
 
             # 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
+            runs_to_process = session_runs[-last_n_runs:] if last_n_runs is not None else session_runs
 
             for run_response in runs_to_process:
                 if not (run_response and run_response.messages):
                     continue
 
                 for message in run_response.messages or []:
-                    if self._should_skip_message(message, skip_role, skip_history_messages):
+                    if _should_skip_message(message, skip_roles, skip_history_messages):
                         continue
 
                     if message.role == "system":
@@ -223,6 +231,18 @@ class TeamSession:
         log_debug(f"Getting messages from previous runs: {len(messages_from_history)}")
         return messages_from_history
 
+    def get_chat_history(self, last_n_runs: Optional[int] = None) -> List[Message]:
+        """Return the chat history (user and assistant messages) for the session.
+        Use get_messages() for more filtering options.
+
+        Args:
+            last_n_runs: Number of recent runs to include. If None, all runs will be considered.
+
+        Returns:
+            A list of user and assistant Messages belonging to the session.
+        """
+        return self.get_messages(skip_roles=["system", "tool"], skip_member_messages=True, last_n_runs=last_n_runs)
+
     def get_tool_calls(self, num_calls: Optional[int] = None) -> List[Dict[str, Any]]:
         """Returns a list of tool calls from the messages"""
 
@@ -241,49 +261,6 @@ class TeamSession:
                                 return tool_calls
         return tool_calls
 
-    def get_messages_for_session(
-        self,
-        user_role: str = "user",
-        assistant_role: Optional[List[str]] = None,
-        skip_history_messages: bool = True,
-    ) -> List[Message]:
-        """Returns a list of messages for the session that iterate through user message and assistant response."""
-
-        if assistant_role is None:
-            # TODO: Check if we still need CHATBOT as a role
-            assistant_role = ["assistant", "model", "CHATBOT"]
-
-        final_messages: List[Message] = []
-        session_runs = self.runs
-        if session_runs is None:
-            return []
-
-        for run_response in session_runs:
-            if run_response and run_response.messages:
-                user_message_from_run = None
-                assistant_message_from_run = None
-
-                # Start from the beginning to look for the user message
-                for message in run_response.messages or []:
-                    if hasattr(message, "from_history") and message.from_history and skip_history_messages:
-                        continue
-                    if message.role == user_role:
-                        user_message_from_run = message
-                        break
-
-                # Start from the end to look for the assistant response
-                for message in run_response.messages[::-1]:
-                    if hasattr(message, "from_history") and message.from_history and skip_history_messages:
-                        continue
-                    if message.role in assistant_role:
-                        assistant_message_from_run = message
-                        break
-
-                if user_message_from_run and assistant_message_from_run:
-                    final_messages.append(user_message_from_run)
-                    final_messages.append(assistant_message_from_run)
-        return final_messages
-
     def get_team_history(self, num_runs: Optional[int] = None) -> List[Tuple[str, str]]:
         """Get team history as structured data (input, response pairs) -> This is the history of the team leader, not the members.
 
@@ -363,30 +340,3 @@ class TeamSession:
             return None
 
         return self.summary  # type: ignore
-
-    # Chat History functions
-    def get_chat_history(
-        self, skip_history_messages: bool = True, skip_roles: Optional[List[str]] = None
-    ) -> List[Message]:
-        """
-        Get the chat history for the session.
-        This is all messages across all runs for the team leader.
-        """
-
-        messages = []
-        if self.runs is None:
-            return []
-
-        for run in self.runs or []:
-            if run.parent_run_id is not None:
-                continue
-
-            if run.messages is not None:
-                for msg in run.messages or []:
-                    if skip_history_messages and msg.from_history:
-                        continue
-                    if skip_roles and msg.role in skip_roles:
-                        continue
-                    messages.append(msg)
-
-        return messages