agno 2.0.1__py3-none-any.whl → 2.3.0__py3-none-any.whl

agno/session/summary.py

@@ -1,11 +1,12 @@
 from dataclasses import dataclass
 from datetime import datetime
 from textwrap import dedent
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union, cast
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union
 
 from pydantic import BaseModel, Field
 
 from agno.models.base import Model
+from agno.models.utils import get_model
 from agno.run.agent import Message
 from agno.utils.log import log_debug, log_warning
 
@@ -66,6 +67,9 @@ class SessionSummaryManager:
     # Prompt used for session summary generation
     session_summary_prompt: Optional[str] = None
 
+    # User message prompt for requesting the summary
+    summary_request_message: str = "Provide the summary of the conversation."
+
     # Whether session summaries were created in the last run
     summaries_updated: bool = False
 
@@ -90,20 +94,35 @@ class SessionSummaryManager:
         response_format: Union[Dict[str, Any], Type[BaseModel]],
     ) -> Message:
         if self.session_summary_prompt is not None:
-            return Message(role="system", content=self.session_summary_prompt)
-
-        system_prompt = dedent("""\
-        Analyze the following conversation between a user and an assistant, and extract the following details:
-          - Summary (str): Provide a concise summary of the session, focusing on important information that would be helpful for future interactions.
-          - Topics (Optional[List[str]]): List the topics discussed in the session.
-        Keep the summary concise and to the point. Only include relevant information.
-
-        <conversation>
-        """)
+            system_prompt = self.session_summary_prompt
+        else:
+            system_prompt = dedent("""\
+            Analyze the following conversation between a user and an assistant, and extract the following details:
+            - Summary (str): Provide a concise summary of the session, focusing on important information that would be helpful for future interactions.
+            - Topics (Optional[List[str]]): List the topics discussed in the session.
+            Keep the summary concise and to the point. Only include relevant information.
+            """)
         conversation_messages = []
+        system_prompt += "<conversation>"
         for message in conversation:
             if message.role == "user":
-                conversation_messages.append(f"User: {message.content}")
+                # Handle empty user messages with media - note what media was provided
+                if not message.content or (isinstance(message.content, str) and message.content.strip() == ""):
+                    media_types = []
+                    if hasattr(message, "images") and message.images:
+                        media_types.append(f"{len(message.images)} image(s)")
+                    if hasattr(message, "videos") and message.videos:
+                        media_types.append(f"{len(message.videos)} video(s)")
+                    if hasattr(message, "audio") and message.audio:
+                        media_types.append(f"{len(message.audio)} audio file(s)")
+                    if hasattr(message, "files") and message.files:
+                        media_types.append(f"{len(message.files)} file(s)")
+
+                    if media_types:
+                        conversation_messages.append(f"User: [Provided {', '.join(media_types)}]")
+                    # Skip empty messages with no media
+                else:
+                    conversation_messages.append(f"User: {message.content}")
             elif message.role in ["assistant", "model"]:
                 conversation_messages.append(f"Assistant: {message.content}\n")
         system_prompt += "\n".join(conversation_messages)
@@ -119,23 +138,30 @@ class SessionSummaryManager:
     def _prepare_summary_messages(
         self,
         session: Optional["Session"] = None,
-    ) -> List[Message]:
-        """Prepare messages for session summary generation"""
-        self.model = cast(Model, self.model)
+    ) -> Optional[List[Message]]:
+        """Prepare messages for session summary generation. Returns None if no meaningful messages to summarize."""
+        if not session:
+            return None
+
+        self.model = get_model(self.model)
+        if self.model is None:
+            return None
+
         response_format = self.get_response_format(self.model)
 
-        return (
-            [
-                self.get_system_message(
-                    conversation=session.get_messages_for_session(),  # type: ignore
-                    response_format=response_format,
-                ),
-                Message(role="user", content="Provide the summary of the conversation."),
-            ]
-            if session
-            else []
+        system_message = self.get_system_message(
+            conversation=session.get_messages(),  # type: ignore
+            response_format=response_format,
         )
 
+        if system_message is None:
+            return None
+
+        return [
+            system_message,
+            Message(role="user", content=self.summary_request_message),
+        ]
+
     def _process_summary_response(self, summary_response, session_summary_model: "Model") -> Optional[SessionSummary]:  # type: ignore
         """Process the model response into a SessionSummary"""
         from datetime import datetime
@@ -188,10 +214,17 @@ class SessionSummaryManager:
     ) -> Optional[SessionSummary]:
         """Creates a summary of the session"""
         log_debug("Creating session summary", center=True)
+        self.model = get_model(self.model)
         if self.model is None:
             return None
 
         messages = self._prepare_summary_messages(session)
+
+        # Skip summary generation if there are no meaningful messages
+        if messages is None:
+            log_debug("No meaningful messages to summarize, skipping session summary")
+            return None
+
         response_format = self.get_response_format(self.model)
 
         summary_response = self.model.response(messages=messages, response_format=response_format)
@@ -209,10 +242,17 @@ class SessionSummaryManager:
     ) -> Optional[SessionSummary]:
         """Creates a summary of the session"""
         log_debug("Creating session summary", center=True)
+        self.model = get_model(self.model)
         if self.model is None:
             return None
 
         messages = self._prepare_summary_messages(session)
+
+        # Skip summary generation if there are no meaningful messages
+        if messages is None:
+            log_debug("No meaningful messages to summarize, skipping session summary")
+            return None
+
         response_format = self.get_response_format(self.model)
 
         summary_response = await self.model.aresponse(messages=messages, response_format=response_format)

agno/session/team.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 from dataclasses import asdict, dataclass
-from typing import Any, Dict, List, Mapping, Optional, Union
+from typing import Any, Dict, List, Mapping, Optional, Tuple, Union
+
+from pydantic import BaseModel
 
 from agno.models.message import Message
 from agno.run.agent import RunOutput, RunStatus
@@ -54,16 +56,18 @@ class TeamSession:
             log_warning("TeamSession is missing session_id")
             return None
 
-        if data.get("summary") is not None:
+        summary = data.get("summary")
+        if summary is not None and isinstance(summary, dict):
             data["summary"] = SessionSummary.from_dict(data["summary"])  # type: ignore
 
-        runs = data.get("runs", [])
+        runs = data.get("runs")
         serialized_runs: List[Union[TeamRunOutput, RunOutput]] = []
-        for run in runs:
-            if "agent_id" in run:
-                serialized_runs.append(RunOutput.from_dict(run))
-            elif "team_id" in run:
-                serialized_runs.append(TeamRunOutput.from_dict(run))
+        if runs is not None and isinstance(runs[0], dict):
+            for run in runs:
+                if "agent_id" in run:
+                    serialized_runs.append(RunOutput.from_dict(run))
+                elif "team_id" in run:
+                    serialized_runs.append(TeamRunOutput.from_dict(run))
 
         return cls(
             session_id=data.get("session_id"),  # type: ignore
@@ -92,6 +96,7 @@ class TeamSession:
         if messages is None:
             return
 
+        # Make message duration None
         for m in messages or []:
             if m.metrics is not None:
                 m.metrics.duration = None
@@ -108,74 +113,136 @@ class TeamSession:
 
         log_debug("Added RunOutput to Team Session")
 
-    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,
-        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.
-            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:
-            # Filter for the main team 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
 
-        # 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 with specified role
-                if skip_role and message.role == skip_role:
+        # 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
-                # Skip messages that were tagged as history in previous runs
-                if hasattr(message, "from_history") and message.from_history and skip_history_messages:
+
+                for message in run_response.messages or []:
+                    if _should_skip_message(message, skip_roles, 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[
+                    -(limit - 1) :
+                ]  # Grab one less message then add the system message
+            else:
+                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_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
-                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 _should_skip_message(message, skip_roles, 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
 
+    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"""
 
@@ -194,69 +261,82 @@ 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."""
+    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.
 
-        if assistant_role is None:
-            # TODO: Check if we still need CHATBOT as a role
-            assistant_role = ["assistant", "model", "CHATBOT"]
+        Args:
+            num_runs: Number of recent runs to include. If None, returns all available history.
+        """
+        if not self.runs:
+            return []
 
-        final_messages: List[Message] = []
-        session_runs = self.runs
-        if session_runs is None:
+        from agno.run.base import RunStatus
+
+        # Get completed runs only (exclude current/pending run)
+        completed_runs = [run for run in self.runs if run.status == RunStatus.completed and run.parent_run_id is None]
+
+        if num_runs is not None and len(completed_runs) > num_runs:
+            recent_runs = completed_runs[-num_runs:]
+        else:
+            recent_runs = completed_runs
+
+        if not recent_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
+        # Return structured data as list of (input, response) tuples
+        history_data = []
+        for run in recent_runs:
+            # Get input
+            input_str = ""
+            if run.input:
+                input_str = run.input.input_content_string()
 
-                # 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
+            # Get response
+            response_str = ""
+            if run.content:
+                response_str = (
+                    run.content.model_dump_json(indent=2, exclude_none=True)
+                    if isinstance(run.content, BaseModel)
+                    else str(run.content)
+                )
 
-                # 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
+            history_data.append((input_str, response_str))
 
-                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
+        return history_data
 
-    def get_session_summary(self) -> Optional[SessionSummary]:
-        """Get the session summary for the session"""
+    def get_team_history_context(self, num_runs: Optional[int] = None) -> Optional[str]:
+        """Get formatted team history context for steps
 
-        if self.summary is None:
+        Args:
+            num_runs: Number of recent runs to include. If None, returns all available history.
+        """
+        history_data = self.get_team_history(num_runs)
+
+        if not history_data:
             return None
 
-        return self.summary  # type: ignore
+        # Format as team history context using the structured data
+        context_parts = ["<team_history_context>"]
 
-    # Chat History functions
-    def get_chat_history(self) -> List[Message]:
-        """Get the chat history for the session"""
+        for i, (input_str, response_str) in enumerate(history_data, 1):
+            context_parts.append(f"[run-{i}]")
 
-        messages = []
-        if self.runs is None:
-            return []
+            if input_str:
+                context_parts.append(f"input: {input_str}")
+            if response_str:
+                context_parts.append(f"response: {response_str}")
 
-        for run in self.runs or []:
-            if run.messages is None:
-                continue
+            context_parts.append("")  # Empty line between runs
+
+        context_parts.append("</team_history_context>")
+        context_parts.append("")  # Empty line before current input
 
-            messages.extend([msg for msg in run.messages or [] if not msg.from_history])
+        return "\n".join(context_parts)
 
-        return 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  # type: ignore