agno 2.1.9__py3-none-any.whl → 2.2.0__py3-none-any.whl

agno/tools/gmail.py

@@ -124,20 +124,6 @@ class GmailTools(Toolkit):
         self.scopes = scopes or self.DEFAULT_SCOPES
         self.port = port
 
-        """ tools functions:
-         enable_get_latest_emails (bool): Enable getting latest emails.
-         enable_get_emails_from_user (bool): Enable getting emails from specific user.
-         enable_get_unread_emails (bool): Enable getting unread emails.
-         enable_get_starred_emails (bool): Enable getting starred emails.
-         enable_get_emails_by_context (bool): Enable getting emails by context.
-         enable_get_emails_by_date (bool): Enable getting emails by date.
-         enable_get_emails_by_thread (bool): Enable getting emails by thread.
-         enable_create_draft_email (bool): Enable creating draft emails.
-         enable_send_email (bool): Enable sending emails.
-         enable_send_email_reply (bool): Enable sending email replies.
-         all (bool): Enable all tools.
-        """
-
         tools: List[Any] = [
             # Reading emails
             self.get_latest_emails,
@@ -148,6 +134,9 @@ class GmailTools(Toolkit):
             self.get_emails_by_date,
             self.get_emails_by_thread,
             self.search_emails,
+            # Email management
+            self.mark_email_as_read,
+            self.mark_email_as_unread,
             # Composing emails
             self.create_draft_email,
             self.send_email,
@@ -173,12 +162,18 @@ class GmailTools(Toolkit):
             "get_emails_by_thread",
             "search_emails",
         ]
+        modify_operations = ["mark_email_as_read", "mark_email_as_unread"]
         if any(read_operation in self.functions for read_operation in read_operations):
             read_scope = "https://www.googleapis.com/auth/gmail.readonly"
             write_scope = "https://www.googleapis.com/auth/gmail.modify"
             if read_scope not in self.scopes and write_scope not in self.scopes:
                 raise ValueError(f"The scope {read_scope} is required for email reading operations")
 
+        if any(modify_operation in self.functions for modify_operation in modify_operations):
+            modify_scope = "https://www.googleapis.com/auth/gmail.modify"
+            if modify_scope not in self.scopes:
+                raise ValueError(f"The scope {modify_scope} is required for email modification operations")
+
     def _auth(self) -> None:
         """Authenticate with Gmail API"""
         token_file = Path(self.token_path or "token.json")
@@ -555,6 +550,56 @@ class GmailTools(Toolkit):
         except Exception as error:
             return f"Unexpected error retrieving emails with query '{query}': {type(error).__name__}: {error}"
 
+    @authenticate
+    def mark_email_as_read(self, message_id: str) -> str:
+        """
+        Mark a specific email as read by removing the 'UNREAD' label.
+        This is crucial for long polling scenarios to prevent processing the same email multiple times.
+
+        Args:
+            message_id (str): The ID of the message to mark as read
+
+        Returns:
+            str: Success message or error description
+        """
+        try:
+            # Remove the UNREAD label to mark the email as read
+            modify_request = {"removeLabelIds": ["UNREAD"]}
+
+            self.service.users().messages().modify(userId="me", id=message_id, body=modify_request).execute()  # type: ignore
+
+            return f"Successfully marked email {message_id} as read. Labels removed: UNREAD"
+
+        except HttpError as error:
+            return f"HTTP Error marking email {message_id} as read: {error}"
+        except Exception as error:
+            return f"Error marking email {message_id} as read: {type(error).__name__}: {error}"
+
+    @authenticate
+    def mark_email_as_unread(self, message_id: str) -> str:
+        """
+        Mark a specific email as unread by adding the 'UNREAD' label.
+        This is useful for flagging emails that need attention or re-processing.
+
+        Args:
+            message_id (str): The ID of the message to mark as unread
+
+        Returns:
+            str: Success message or error description
+        """
+        try:
+            # Add the UNREAD label to mark the email as unread
+            modify_request = {"addLabelIds": ["UNREAD"]}
+
+            self.service.users().messages().modify(userId="me", id=message_id, body=modify_request).execute()  # type: ignore
+
+            return f"Successfully marked email {message_id} as unread. Labels added: UNREAD"
+
+        except HttpError as error:
+            return f"HTTP Error marking email {message_id} as unread: {error}"
+        except Exception as error:
+            return f"Error marking email {message_id} as unread: {type(error).__name__}: {error}"
+
     def _validate_email_params(self, to: str, subject: str, body: str) -> None:
         """Validate email parameters."""
         if not to:

agno/utils/agent.py

@@ -0,0 +1,372 @@
+from asyncio import Future, Task
+from typing import AsyncIterator, Iterator, List, Optional, Sequence, Union
+
+from agno.media import Audio, File, Image, Video
+from agno.models.message import Message
+from agno.run.agent import RunEvent, RunInput, RunOutput, RunOutputEvent
+from agno.run.team import RunOutputEvent as TeamRunOutputEvent
+from agno.run.team import TeamRunOutput
+from agno.session import AgentSession, TeamSession
+from agno.utils.events import (
+    create_memory_update_completed_event,
+    create_memory_update_started_event,
+    create_team_memory_update_completed_event,
+    create_team_memory_update_started_event,
+    handle_event,
+)
+from agno.utils.log import log_debug, log_warning
+
+
+async def await_for_background_tasks(
+    memory_task: Optional[Task] = None,
+    cultural_knowledge_task: Optional[Task] = None,
+) -> None:
+    if memory_task is not None:
+        try:
+            await memory_task
+        except Exception as e:
+            log_warning(f"Error in memory creation: {str(e)}")
+
+    if cultural_knowledge_task is not None:
+        try:
+            await cultural_knowledge_task
+        except Exception as e:
+            log_warning(f"Error in cultural knowledge creation: {str(e)}")
+
+
+def wait_for_background_tasks(
+    memory_future: Optional[Future] = None, cultural_knowledge_future: Optional[Future] = None
+) -> None:
+    if memory_future is not None:
+        try:
+            memory_future.result()
+        except Exception as e:
+            log_warning(f"Error in memory creation: {str(e)}")
+
+    # Wait for cultural knowledge creation
+    if cultural_knowledge_future is not None:
+        try:
+            cultural_knowledge_future.result()
+        except Exception as e:
+            log_warning(f"Error in cultural knowledge creation: {str(e)}")
+
+
+async def await_for_background_tasks_stream(
+    run_response: Union[RunOutput, TeamRunOutput],
+    memory_task: Optional[Task] = None,
+    cultural_knowledge_task: Optional[Task] = None,
+    stream_events: bool = False,
+    events_to_skip: Optional[List[RunEvent]] = None,
+    store_events: bool = False,
+) -> AsyncIterator[RunOutputEvent]:
+    if memory_task is not None:
+        if stream_events:
+            if isinstance(run_response, TeamRunOutput):
+                yield handle_event(  # type: ignore
+                    create_team_memory_update_started_event(from_run_response=run_response),
+                    run_response,
+                    events_to_skip=events_to_skip,  # type: ignore
+                    store_events=store_events,
+                )
+            else:
+                yield handle_event(  # type: ignore
+                    create_memory_update_started_event(from_run_response=run_response),
+                    run_response,
+                    events_to_skip=events_to_skip,  # type: ignore
+                    store_events=store_events,
+                )
+        try:
+            await memory_task
+        except Exception as e:
+            log_warning(f"Error in memory creation: {str(e)}")
+        if stream_events:
+            if isinstance(run_response, TeamRunOutput):
+                yield handle_event(  # type: ignore
+                    create_team_memory_update_completed_event(from_run_response=run_response),
+                    run_response,
+                    events_to_skip=events_to_skip,  # type: ignore
+                    store_events=store_events,
+                )
+            else:
+                yield handle_event(  # type: ignore
+                    create_memory_update_completed_event(from_run_response=run_response),
+                    run_response,
+                    events_to_skip=events_to_skip,  # type: ignore
+                    store_events=store_events,
+                )
+
+    if cultural_knowledge_task is not None:
+        try:
+            await cultural_knowledge_task
+        except Exception as e:
+            log_warning(f"Error in cultural knowledge creation: {str(e)}")
+
+
+def wait_for_background_tasks_stream(
+    run_response: Union[TeamRunOutput, RunOutput],
+    memory_future: Optional[Future] = None,
+    cultural_knowledge_future: Optional[Future] = None,
+    stream_events: bool = False,
+    events_to_skip: Optional[List[RunEvent]] = None,
+    store_events: bool = False,
+) -> Iterator[Union[RunOutputEvent, TeamRunOutputEvent]]:
+    if memory_future is not None:
+        if stream_events:
+            if isinstance(run_response, TeamRunOutput):
+                yield handle_event(  # type: ignore
+                    create_team_memory_update_started_event(from_run_response=run_response),
+                    run_response,
+                    events_to_skip=events_to_skip,  # type: ignore
+                    store_events=store_events,
+                )
+            else:
+                yield handle_event(  # type: ignore
+                    create_memory_update_started_event(from_run_response=run_response),
+                    run_response,
+                    events_to_skip=events_to_skip,  # type: ignore
+                    store_events=store_events,
+                )
+        try:
+            memory_future.result()
+        except Exception as e:
+            log_warning(f"Error in memory creation: {str(e)}")
+        if stream_events:
+            if isinstance(run_response, TeamRunOutput):
+                yield handle_event(  # type: ignore
+                    create_team_memory_update_completed_event(from_run_response=run_response),
+                    run_response,
+                    events_to_skip=events_to_skip,  # type: ignore
+                    store_events=store_events,
+                )
+            else:
+                yield handle_event(  # type: ignore
+                    create_memory_update_completed_event(from_run_response=run_response),
+                    run_response,
+                    events_to_skip=events_to_skip,  # type: ignore
+                    store_events=store_events,
+                )
+
+    # Wait for cultural knowledge creation
+    if cultural_knowledge_future is not None:
+        # TODO: Add events
+        try:
+            cultural_knowledge_future.result()
+        except Exception as e:
+            log_warning(f"Error in cultural knowledge creation: {str(e)}")
+
+
+def collect_joint_images(
+    run_input: Optional[RunInput] = None,
+    session: Optional[Union[AgentSession, TeamSession]] = None,
+) -> Optional[Sequence[Image]]:
+    """Collect images from input, session history, and current run response."""
+    joint_images: List[Image] = []
+
+    # 1. Add images from current input
+    if run_input and run_input.images:
+        joint_images.extend(run_input.images)
+        log_debug(f"Added {len(run_input.images)} input images to joint list")
+
+    # 2. Add images from session history (from both input and generated sources)
+    try:
+        if session and session.runs:
+            for historical_run in session.runs:
+                # Add generated images from previous runs
+                if historical_run.images:
+                    joint_images.extend(historical_run.images)
+                    log_debug(
+                        f"Added {len(historical_run.images)} generated images from historical run {historical_run.run_id}"
+                    )
+
+                # Add input images from previous runs
+                if historical_run.input and historical_run.input.images:
+                    joint_images.extend(historical_run.input.images)
+                    log_debug(
+                        f"Added {len(historical_run.input.images)} input images from historical run {historical_run.run_id}"
+                    )
+    except Exception as e:
+        log_debug(f"Could not access session history for images: {e}")
+
+    if joint_images:
+        log_debug(f"Images Available to Model: {len(joint_images)} images")
+    return joint_images if joint_images else None
+
+
+def collect_joint_videos(
+    run_input: Optional[RunInput] = None,
+    session: Optional[Union[AgentSession, TeamSession]] = None,
+) -> Optional[Sequence[Video]]:
+    """Collect videos from input, session history, and current run response."""
+    joint_videos: List[Video] = []
+
+    # 1. Add videos from current input
+    if run_input and run_input.videos:
+        joint_videos.extend(run_input.videos)
+        log_debug(f"Added {len(run_input.videos)} input videos to joint list")
+
+    # 2. Add videos from session history (from both input and generated sources)
+    try:
+        if session and session.runs:
+            for historical_run in session.runs:
+                # Add generated videos from previous runs
+                if historical_run.videos:
+                    joint_videos.extend(historical_run.videos)
+                    log_debug(
+                        f"Added {len(historical_run.videos)} generated videos from historical run {historical_run.run_id}"
+                    )
+
+                # Add input videos from previous runs
+                if historical_run.input and historical_run.input.videos:
+                    joint_videos.extend(historical_run.input.videos)
+                    log_debug(
+                        f"Added {len(historical_run.input.videos)} input videos from historical run {historical_run.run_id}"
+                    )
+    except Exception as e:
+        log_debug(f"Could not access session history for videos: {e}")
+
+    if joint_videos:
+        log_debug(f"Videos Available to Model: {len(joint_videos)} videos")
+    return joint_videos if joint_videos else None
+
+
+def collect_joint_audios(
+    run_input: Optional[RunInput] = None,
+    session: Optional[Union[AgentSession, TeamSession]] = None,
+) -> Optional[Sequence[Audio]]:
+    """Collect audios from input, session history, and current run response."""
+    joint_audios: List[Audio] = []
+
+    # 1. Add audios from current input
+    if run_input and run_input.audios:
+        joint_audios.extend(run_input.audios)
+        log_debug(f"Added {len(run_input.audios)} input audios to joint list")
+
+    # 2. Add audios from session history (from both input and generated sources)
+    try:
+        if session and session.runs:
+            for historical_run in session.runs:
+                # Add generated audios from previous runs
+                if historical_run.audio:
+                    joint_audios.extend(historical_run.audio)
+                    log_debug(
+                        f"Added {len(historical_run.audio)} generated audios from historical run {historical_run.run_id}"
+                    )
+
+                # Add input audios from previous runs
+                if historical_run.input and historical_run.input.audios:
+                    joint_audios.extend(historical_run.input.audios)
+                    log_debug(
+                        f"Added {len(historical_run.input.audios)} input audios from historical run {historical_run.run_id}"
+                    )
+    except Exception as e:
+        log_debug(f"Could not access session history for audios: {e}")
+
+    if joint_audios:
+        log_debug(f"Audios Available to Model: {len(joint_audios)} audios")
+    return joint_audios if joint_audios else None
+
+
+def collect_joint_files(
+    run_input: Optional[RunInput] = None,
+) -> Optional[Sequence[File]]:
+    """Collect files from input and session history."""
+    from agno.utils.log import log_debug
+
+    joint_files: List[File] = []
+
+    # 1. Add files from current input
+    if run_input and run_input.files:
+        joint_files.extend(run_input.files)
+
+    # TODO: Files aren't stored in session history yet and dont have a FileArtifact
+
+    if joint_files:
+        log_debug(f"Files Available to Model: {len(joint_files)} files")
+
+    return joint_files if joint_files else None
+
+
+def scrub_media_from_run_output(run_response: Union[RunOutput, TeamRunOutput]) -> None:
+    """
+    Completely remove all media from RunOutput when store_media=False.
+    This includes media in input, output artifacts, and all messages.
+    """
+    # 1. Scrub RunInput media
+    if run_response.input is not None:
+        run_response.input.images = []
+        run_response.input.videos = []
+        run_response.input.audios = []
+        run_response.input.files = []
+
+    # 3. Scrub media from all messages
+    if run_response.messages:
+        for message in run_response.messages:
+            scrub_media_from_message(message)
+
+    # 4. Scrub media from additional_input messages if any
+    if run_response.additional_input:
+        for message in run_response.additional_input:
+            scrub_media_from_message(message)
+
+    # 5. Scrub media from reasoning_messages if any
+    if run_response.reasoning_messages:
+        for message in run_response.reasoning_messages:
+            scrub_media_from_message(message)
+
+
+def scrub_media_from_message(message: Message) -> None:
+    """Remove all media from a Message object."""
+    # Input media
+    message.images = None
+    message.videos = None
+    message.audio = None
+    message.files = None
+
+    # Output media
+    message.audio_output = None
+    message.image_output = None
+    message.video_output = None
+
+
+def scrub_tool_results_from_run_output(run_response: Union[RunOutput, TeamRunOutput]) -> None:
+    """
+    Remove all tool-related data from RunOutput when store_tool_messages=False.
+    This removes both the tool call and its corresponding result to maintain API consistency.
+    """
+    if not run_response.messages:
+        return
+
+    # Step 1: Collect all tool_call_ids from tool result messages
+    tool_call_ids_to_remove = set()
+    for message in run_response.messages:
+        if message.role == "tool" and message.tool_call_id:
+            tool_call_ids_to_remove.add(message.tool_call_id)
+
+    # Step 2: Remove tool result messages (role="tool")
+    run_response.messages = [msg for msg in run_response.messages if msg.role != "tool"]
+
+    # Step 3: Remove assistant messages that made those tool calls
+    filtered_messages = []
+    for message in run_response.messages:
+        # Check if this assistant message made any of the tool calls we're removing
+        should_remove = False
+        if message.role == "assistant" and message.tool_calls:
+            for tool_call in message.tool_calls:
+                if tool_call.get("id") in tool_call_ids_to_remove:
+                    should_remove = True
+                    break
+
+        if not should_remove:
+            filtered_messages.append(message)
+
+    run_response.messages = filtered_messages
+
+
+def scrub_history_messages_from_run_output(run_response: Union[RunOutput, TeamRunOutput]) -> None:
+    """
+    Remove all history messages from TeamRunOutput when store_history_messages=False.
+    This removes messages that were loaded from the team's memory.
+    """
+    # Remove messages with from_history=True
+    if run_response.messages:
+        run_response.messages = [msg for msg in run_response.messages if not msg.from_history]

agno/utils/events.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 from agno.media import Audio, Image
 from agno.models.message import Citations
@@ -11,6 +11,8 @@ from agno.run.agent import (
     OutputModelResponseStartedEvent,
     ParserModelResponseCompletedEvent,
     ParserModelResponseStartedEvent,
+    PostHookCompletedEvent,
+    PostHookStartedEvent,
     PreHookCompletedEvent,
     PreHookStartedEvent,
     ReasoningCompletedEvent,
@@ -18,13 +20,18 @@ from agno.run.agent import (
     ReasoningStepEvent,
     RunCancelledEvent,
     RunCompletedEvent,
+    RunContentCompletedEvent,
     RunContentEvent,
     RunContinuedEvent,
     RunErrorEvent,
+    RunEvent,
     RunInput,
     RunOutput,
+    RunOutputEvent,
     RunPausedEvent,
     RunStartedEvent,
+    SessionSummaryCompletedEvent,
+    SessionSummaryStartedEvent,
     ToolCallCompletedEvent,
     ToolCallStartedEvent,
 )
@@ -34,6 +41,8 @@ from agno.run.team import OutputModelResponseCompletedEvent as TeamOutputModelRe
 from agno.run.team import OutputModelResponseStartedEvent as TeamOutputModelResponseStartedEvent
 from agno.run.team import ParserModelResponseCompletedEvent as TeamParserModelResponseCompletedEvent
 from agno.run.team import ParserModelResponseStartedEvent as TeamParserModelResponseStartedEvent
+from agno.run.team import PostHookCompletedEvent as TeamPostHookCompletedEvent
+from agno.run.team import PostHookStartedEvent as TeamPostHookStartedEvent
 from agno.run.team import PreHookCompletedEvent as TeamPreHookCompletedEvent
 from agno.run.team import PreHookStartedEvent as TeamPreHookStartedEvent
 from agno.run.team import ReasoningCompletedEvent as TeamReasoningCompletedEvent
@@ -41,12 +50,16 @@ from agno.run.team import ReasoningStartedEvent as TeamReasoningStartedEvent
 from agno.run.team import ReasoningStepEvent as TeamReasoningStepEvent
 from agno.run.team import RunCancelledEvent as TeamRunCancelledEvent
 from agno.run.team import RunCompletedEvent as TeamRunCompletedEvent
+from agno.run.team import RunContentCompletedEvent as TeamRunContentCompletedEvent
 from agno.run.team import RunContentEvent as TeamRunContentEvent
 from agno.run.team import RunErrorEvent as TeamRunErrorEvent
 from agno.run.team import RunStartedEvent as TeamRunStartedEvent
-from agno.run.team import TeamRunInput, TeamRunOutput
+from agno.run.team import SessionSummaryCompletedEvent as TeamSessionSummaryCompletedEvent
+from agno.run.team import SessionSummaryStartedEvent as TeamSessionSummaryStartedEvent
+from agno.run.team import TeamRunEvent, TeamRunInput, TeamRunOutput, TeamRunOutputEvent
 from agno.run.team import ToolCallCompletedEvent as TeamToolCallCompletedEvent
 from agno.run.team import ToolCallStartedEvent as TeamToolCallStartedEvent
+from agno.session.summary import SessionSummary
 
 
 def create_team_run_started_event(from_run_response: TeamRunOutput) -> TeamRunStartedEvent:
@@ -242,6 +255,54 @@ def create_team_pre_hook_completed_event(
     )
 
 
+def create_post_hook_started_event(
+    from_run_response: RunOutput, post_hook_name: Optional[str] = None
+) -> PostHookStartedEvent:
+    return PostHookStartedEvent(
+        session_id=from_run_response.session_id,
+        agent_id=from_run_response.agent_id,  # type: ignore
+        agent_name=from_run_response.agent_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        post_hook_name=post_hook_name,
+    )
+
+
+def create_team_post_hook_started_event(
+    from_run_response: TeamRunOutput, post_hook_name: Optional[str] = None
+) -> TeamPostHookStartedEvent:
+    return TeamPostHookStartedEvent(
+        session_id=from_run_response.session_id,
+        team_id=from_run_response.team_id,  # type: ignore
+        team_name=from_run_response.team_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        post_hook_name=post_hook_name,
+    )
+
+
+def create_post_hook_completed_event(
+    from_run_response: RunOutput, post_hook_name: Optional[str] = None
+) -> PostHookCompletedEvent:
+    return PostHookCompletedEvent(
+        session_id=from_run_response.session_id,
+        agent_id=from_run_response.agent_id,  # type: ignore
+        agent_name=from_run_response.agent_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        post_hook_name=post_hook_name,
+    )
+
+
+def create_team_post_hook_completed_event(
+    from_run_response: TeamRunOutput, post_hook_name: Optional[str] = None
+) -> TeamPostHookCompletedEvent:
+    return TeamPostHookCompletedEvent(
+        session_id=from_run_response.session_id,
+        team_id=from_run_response.team_id,  # type: ignore
+        team_name=from_run_response.team_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        post_hook_name=post_hook_name,
+    )
+
+
 def create_memory_update_started_event(from_run_response: RunOutput) -> MemoryUpdateStartedEvent:
     return MemoryUpdateStartedEvent(
         session_id=from_run_response.session_id,
@@ -278,6 +339,50 @@ def create_team_memory_update_completed_event(from_run_response: TeamRunOutput)
     )
 
 
+def create_team_session_summary_started_event(
+    from_run_response: TeamRunOutput,
+) -> TeamSessionSummaryStartedEvent:
+    return TeamSessionSummaryStartedEvent(
+        session_id=from_run_response.session_id,
+        team_id=from_run_response.team_id,  # type: ignore
+        team_name=from_run_response.team_name,  # type: ignore
+        run_id=from_run_response.run_id,
+    )
+
+
+def create_team_session_summary_completed_event(
+    from_run_response: TeamRunOutput, session_summary: Optional[SessionSummary] = None
+) -> TeamSessionSummaryCompletedEvent:
+    return TeamSessionSummaryCompletedEvent(
+        session_id=from_run_response.session_id,
+        team_id=from_run_response.team_id,  # type: ignore
+        team_name=from_run_response.team_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        session_summary=session_summary,
+    )
+
+
+def create_session_summary_started_event(from_run_response: RunOutput) -> SessionSummaryStartedEvent:
+    return SessionSummaryStartedEvent(
+        session_id=from_run_response.session_id,
+        agent_id=from_run_response.agent_id,  # type: ignore
+        agent_name=from_run_response.agent_name,  # type: ignore
+        run_id=from_run_response.run_id,
+    )
+
+
+def create_session_summary_completed_event(
+    from_run_response: RunOutput, session_summary: Optional[SessionSummary] = None
+) -> SessionSummaryCompletedEvent:
+    return SessionSummaryCompletedEvent(
+        session_id=from_run_response.session_id,
+        agent_id=from_run_response.agent_id,  # type: ignore
+        agent_name=from_run_response.agent_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        session_summary=session_summary,
+    )
+
+
 def create_reasoning_started_event(from_run_response: RunOutput) -> ReasoningStartedEvent:
     return ReasoningStartedEvent(
         session_id=from_run_response.session_id,
@@ -468,6 +573,28 @@ def create_team_run_output_content_event(
     )
 
 
+def create_run_content_completed_event(
+    from_run_response: RunOutput,
+) -> RunContentCompletedEvent:
+    return RunContentCompletedEvent(
+        session_id=from_run_response.session_id,
+        agent_id=from_run_response.agent_id,  # type: ignore
+        agent_name=from_run_response.agent_name,  # type: ignore
+        run_id=from_run_response.run_id,
+    )
+
+
+def create_team_run_content_completed_event(
+    from_run_response: TeamRunOutput,
+) -> TeamRunContentCompletedEvent:
+    return TeamRunContentCompletedEvent(
+        session_id=from_run_response.session_id,
+        team_id=from_run_response.team_id,  # type: ignore
+        team_name=from_run_response.team_name,  # type: ignore
+        run_id=from_run_response.run_id,
+    )
+
+
 def create_parser_model_response_started_event(
     from_run_response: RunOutput,
 ) -> ParserModelResponseStartedEvent:
@@ -550,3 +677,18 @@ def create_team_output_model_response_completed_event(
         team_name=from_run_response.team_name,  # type: ignore
         run_id=from_run_response.run_id,
     )
+
+
+def handle_event(
+    event: Union[RunOutputEvent, TeamRunOutputEvent],
+    run_response: Union[RunOutput, TeamRunOutput],
+    events_to_skip: Optional[List[Union[RunEvent, TeamRunEvent]]] = None,
+    store_events: bool = False,
+) -> Union[RunOutputEvent, TeamRunOutputEvent]:
+    # We only store events that are not run_response_content events
+    events_to_skip = [event.value for event in events_to_skip] if events_to_skip else []
+    if store_events and event.event not in events_to_skip:
+        if run_response.events is None:
+            run_response.events = []
+        run_response.events.append(event)  # type: ignore
+    return event