agno 1.8.1__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

agno/session/team.py

@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from typing import Any, Dict, List, Mapping, Optional, Union
+
+from agno.models.message import Message
+from agno.run.agent import RunOutput, RunStatus
+from agno.run.team import TeamRunOutput
+from agno.session.summary import SessionSummary
+from agno.utils.log import log_debug, log_warning
+
+
+@dataclass
+class TeamSession:
+    """Team Session that is stored in the database"""
+
+    # Session UUID
+    session_id: str
+
+    # ID of the team that this session is associated with
+    team_id: Optional[str] = None
+    # ID of the user interacting with this team
+    user_id: Optional[str] = None
+    # ID of the workflow that this session is associated with
+    workflow_id: Optional[str] = None
+
+    # Team Data: agent_id, name and model
+    team_data: Optional[Dict[str, Any]] = None
+    # Session Data: session_name, session_state, images, videos, audio
+    session_data: Optional[Dict[str, Any]] = None
+    # Metadata stored with this team
+    metadata: Optional[Dict[str, Any]] = None
+    # List of all runs in the session
+    runs: Optional[list[Union[TeamRunOutput, RunOutput]]] = None
+    # Summary of the session
+    summary: Optional[SessionSummary] = None
+
+    # The unix timestamp when this session was created
+    created_at: Optional[int] = None
+    # The unix timestamp when this session was last updated
+    updated_at: Optional[int] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        session_dict = asdict(self)
+
+        session_dict["runs"] = [run.to_dict() for run in self.runs] if self.runs else None
+        session_dict["summary"] = self.summary.to_dict() if self.summary else None
+
+        return session_dict
+
+    @classmethod
+    def from_dict(cls, data: Mapping[str, Any]) -> Optional[TeamSession]:
+        if data is None or data.get("session_id") is None:
+            log_warning("TeamSession is missing session_id")
+            return None
+
+        if data.get("summary") is not None:
+            data["summary"] = SessionSummary.from_dict(data["summary"])  # type: ignore
+
+        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))
+
+        return cls(
+            session_id=data.get("session_id"),  # type: ignore
+            team_id=data.get("team_id"),
+            user_id=data.get("user_id"),
+            workflow_id=data.get("workflow_id"),
+            team_data=data.get("team_data"),
+            session_data=data.get("session_data"),
+            metadata=data.get("metadata"),
+            created_at=data.get("created_at"),
+            updated_at=data.get("updated_at"),
+            runs=serialized_runs,
+            summary=data.get("summary"),
+        )
+
+    def get_run(self, run_id: str) -> Optional[Union[TeamRunOutput, RunOutput]]:
+        for run in self.runs or []:
+            if run.run_id == run_id:
+                return run
+        return None
+
+    def upsert_run(self, run_response: Union[TeamRunOutput, RunOutput]):
+        """Adds a RunOutput, together with some calculated data, to the runs list."""
+
+        messages = run_response.messages
+        if messages is None:
+            return
+
+        for m in messages or []:
+            if m.metrics is not None:
+                m.metrics.duration = None
+
+        if not self.runs:
+            self.runs = []
+
+        for i, existing_run in enumerate(self.runs or []):
+            if existing_run.run_id == run_response.run_id:
+                self.runs[i] = run_response
+                break
+        else:
+            self.runs.append(run_response)
+
+        log_debug("Added RunOutput to Team Session")
+
+    def get_messages_from_last_n_runs(
+        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,
+        skip_history_messages: bool = True,
+        member_runs: bool = False,
+    ) -> List[Message]:
+        """Returns the messages from the last_n runs, excluding previously tagged history messages.
+        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.
+            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.
+        Returns:
+            A list of Messages from the specified runs, excluding history messages.
+        """
+        if not self.runs:
+            return []
+
+        if skip_status is None:
+            skip_status = [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
+        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 not member_runs:
+            # Filter for the main team runs
+            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
+
+        # 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:
+                    continue
+                # Skip messages that were tagged as history in previous runs
+                if hasattr(message, "from_history") and message.from_history and 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_tool_calls(self, num_calls: Optional[int] = None) -> List[Dict[str, Any]]:
+        """Returns a list of tool calls from the messages"""
+
+        tool_calls = []
+        session_runs = self.runs
+        if session_runs is None:
+            return []
+
+        for run_response in session_runs[::-1]:
+            if run_response and run_response.messages:
+                for message in run_response.messages or []:
+                    if message.tool_calls:
+                        for tool_call in message.tool_calls:
+                            tool_calls.append(tool_call)
+                            if num_calls and len(tool_calls) >= num_calls:
+                                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_session_summary(self) -> Optional[SessionSummary]:
+        """Get the session summary for the session"""
+
+        if self.summary is None:
+            return None
+
+        return self.summary  # type: ignore
+
+    # Chat History functions
+    def get_chat_history(self) -> List[Message]:
+        """Get the chat history for the session"""
+
+        messages = []
+        if self.runs is None:
+            return []
+
+        for run in self.runs or []:
+            if run.messages is None:
+                continue
+
+            messages.extend([msg for msg in run.messages or [] if not msg.from_history])
+
+        return messages

agno/{storage/session/v2 → session}/workflow.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
+import time
 from dataclasses import dataclass
 from typing import Any, Dict, List, Mapping, Optional
 
-from agno.run.v2.workflow import WorkflowRunResponse
+from agno.run.workflow import WorkflowRunOutput
 from agno.utils.log import logger
 
 
@@ -21,15 +22,15 @@ class WorkflowSession:
     # Workflow name
     workflow_name: Optional[str] = None
 
-    # Workflow runs - stores WorkflowRunResponse objects in memory
-    runs: Optional[List[WorkflowRunResponse]] = None
+    # Workflow runs - stores WorkflowRunOutput objects in memory
+    runs: Optional[List[WorkflowRunOutput]] = None
 
     # Session Data: session_name, session_state, images, videos, audio
     session_data: Optional[Dict[str, Any]] = None
     # Workflow configuration and metadata
     workflow_data: Optional[Dict[str, Any]] = None
-    # Extra Data stored with this workflow session
-    extra_data: Optional[Dict[str, Any]] = None
+    # Metadata stored with this workflow session
+    metadata: Optional[Dict[str, Any]] = None
 
     # The unix timestamp when this session was created
     created_at: Optional[int] = None
@@ -40,7 +41,28 @@ class WorkflowSession:
         if self.runs is None:
             self.runs = []
 
-    def upsert_run(self, run: WorkflowRunResponse) -> None:
+        # Ensure session_data, workflow_data, and metadata are dictionaries, not None
+        if self.session_data is None:
+            self.session_data = {}
+        if self.workflow_data is None:
+            self.workflow_data = {}
+        if self.metadata is None:
+            self.metadata = {}
+
+        # Set timestamps if they're not already set
+        current_time = int(time.time())
+        if self.created_at is None:
+            self.created_at = current_time
+        if self.updated_at is None:
+            self.updated_at = current_time
+
+    def get_run(self, run_id: str) -> Optional[WorkflowRunOutput]:
+        for run in self.runs or []:
+            if run.run_id == run_id:
+                return run
+        return None
+
+    def upsert_run(self, run: WorkflowRunOutput) -> None:
         """Add or update a workflow run (upsert behavior)"""
         if self.runs is None:
             self.runs = []
@@ -48,12 +70,10 @@ class WorkflowSession:
         # Find existing run and update it, or append new one
         for i, existing_run in enumerate(self.runs):
             if existing_run.run_id == run.run_id:
-                # Update existing run
                 self.runs[i] = run
-                return
-
-        # Run not found, append new one
-        self.runs.append(run)
+                break
+        else:
+            self.runs.append(run)
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for storage, serializing runs to dicts"""
@@ -65,14 +85,7 @@ class WorkflowSession:
                 try:
                     runs_data.append(run.to_dict())
                 except Exception as e:
-                    # If run serialization fails, create a minimal representation
-                    runs_data.append(
-                        {
-                            "run_id": getattr(run, "run_id", "unknown"),
-                            "status": str(getattr(run, "status", "unknown")),
-                            "error": f"Serialization failed: {str(e)}",
-                        }
-                    )
+                    raise ValueError(f"Serialization failed: {str(e)}")
         return {
             "session_id": self.session_id,
             "user_id": self.user_id,
@@ -81,7 +94,7 @@ class WorkflowSession:
             "runs": runs_data,
             "session_data": self.session_data,
             "workflow_data": self.workflow_data,
-            "extra_data": self.extra_data,
+            "metadata": self.metadata,
             "created_at": self.created_at,
             "updated_at": self.updated_at,
         }
@@ -93,11 +106,21 @@ class WorkflowSession:
             logger.warning("WorkflowSession is missing session_id")
             return None
 
-        # Deserialize runs from dictionaries back to WorkflowRunResponse objects
+        # Deserialize runs from dictionaries back to WorkflowRunOutput objects
         runs_data = data.get("runs")
-        runs: Optional[List[WorkflowRunResponse]] = None
+        runs: Optional[List[WorkflowRunOutput]] = None
+
         if runs_data is not None:
-            runs = [WorkflowRunResponse.from_dict(run_dict) for run_dict in runs_data]
+            runs = []
+            for run_item in runs_data:
+                if isinstance(run_item, WorkflowRunOutput):
+                    # Already a WorkflowRunOutput object (from deserialize_session_json_fields)
+                    runs.append(run_item)
+                elif isinstance(run_item, dict):
+                    # Still a dictionary, needs to be converted
+                    runs.append(WorkflowRunOutput.from_dict(run_item))
+                else:
+                    logger.warning(f"Unexpected run item type: {type(run_item)}")
 
         return cls(
             session_id=data.get("session_id"),  # type: ignore
@@ -107,7 +130,7 @@ class WorkflowSession:
             runs=runs,
             session_data=data.get("session_data"),
             workflow_data=data.get("workflow_data"),
-            extra_data=data.get("extra_data"),
+            metadata=data.get("metadata"),
             created_at=data.get("created_at"),
             updated_at=data.get("updated_at"),
         )

agno/team/__init__.py

@@ -4,30 +4,29 @@ from agno.run.team import (
     ReasoningCompletedEvent,
     ReasoningStartedEvent,
     ReasoningStepEvent,
-    RunResponseCancelledEvent,
-    RunResponseCompletedEvent,
-    RunResponseContentEvent,
-    RunResponseErrorEvent,
-    RunResponseStartedEvent,
+    RunCancelledEvent,
+    RunCompletedEvent,
+    RunContentEvent,
+    RunErrorEvent,
+    RunStartedEvent,
     TeamRunEvent,
-    TeamRunResponse,
-    TeamRunResponseEvent,
+    TeamRunOutput,
+    TeamRunOutputEvent,
     ToolCallCompletedEvent,
     ToolCallStartedEvent,
 )
-from agno.team.team import RunResponse, Team
+from agno.team.team import Team
 
 __all__ = [
     "Team",
-    "RunResponse",
-    "TeamRunResponse",
-    "TeamRunResponseEvent",
+    "TeamRunOutput",
+    "TeamRunOutputEvent",
     "TeamRunEvent",
-    "RunResponseContentEvent",
-    "RunResponseCancelledEvent",
-    "RunResponseErrorEvent",
-    "RunResponseStartedEvent",
-    "RunResponseCompletedEvent",
+    "RunContentEvent",
+    "RunCancelledEvent",
+    "RunErrorEvent",
+    "RunStartedEvent",
+    "RunCompletedEvent",
     "MemoryUpdateStartedEvent",
     "MemoryUpdateCompletedEvent",
     "ReasoningStartedEvent",