agno 2.1.10__py3-none-any.whl → 2.2.1__py3-none-any.whl

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

agno/utils/message.py

@@ -1,8 +1,68 @@
+from copy import deepcopy
 from typing import Dict, List, Union
 
 from pydantic import BaseModel
 
 from agno.models.message import Message
+from agno.utils.log import log_debug
+
+
+def filter_tool_calls(messages: List[Message], max_tool_calls: int) -> None:
+    """
+    Filter messages (in-place) to keep only the most recent N tool calls.
+
+    Args:
+        messages: List of messages to filter (modified in-place)
+        max_tool_calls: Number of recent tool calls to keep
+    """
+    # Count total tool calls
+    tool_call_count = sum(1 for m in messages if m.role == "tool")
+
+    # No filtering needed
+    if tool_call_count <= max_tool_calls:
+        return
+
+    # Collect tool_call_ids to keep (most recent N)
+    tool_call_ids_list: List[str] = []
+    for msg in reversed(messages):
+        if msg.role == "tool" and len(tool_call_ids_list) < max_tool_calls:
+            if msg.tool_call_id:
+                tool_call_ids_list.append(msg.tool_call_id)
+
+    tool_call_ids_to_keep: set[str] = set(tool_call_ids_list)
+
+    # Filter messages in-place
+    filtered_messages = []
+    for msg in messages:
+        if msg.role == "tool":
+            # Keep only tool results in our window
+            if msg.tool_call_id in tool_call_ids_to_keep:
+                filtered_messages.append(msg)
+        elif msg.role == "assistant" and msg.tool_calls:
+            # Filter tool_calls within the assistant message
+            # Use deepcopy to ensure complete isolation of the filtered message
+            filtered_msg = deepcopy(msg)
+            # Filter tool_calls
+            if filtered_msg.tool_calls is not None:
+                filtered_msg.tool_calls = [
+                    tc for tc in filtered_msg.tool_calls if tc.get("id") in tool_call_ids_to_keep
+                ]
+
+            if filtered_msg.tool_calls:
+                # Has tool_calls remaining, keep it
+                filtered_messages.append(filtered_msg)
+            # skip empty messages
+            elif filtered_msg.content:
+                filtered_msg.tool_calls = None
+                filtered_messages.append(filtered_msg)
+        else:
+            filtered_messages.append(msg)
+
+    messages[:] = filtered_messages
+
+    # Log filtering information
+    num_filtered = tool_call_count - len(tool_call_ids_to_keep)
+    log_debug(f"Filtered {num_filtered} tool calls, kept {len(tool_call_ids_to_keep)}")
 
 
 def get_text_from_message(message: Union[List, Dict, str, Message, BaseModel]) -> str: