agno 2.0.0rc2__py3-none-any.whl → 2.0.2__py3-none-any.whl

agno/run/team.py

@@ -5,7 +5,7 @@ from typing import Any, Dict, List, Optional, Sequence, Union
 
 from pydantic import BaseModel
 
-from agno.media import AudioArtifact, AudioResponse, File, ImageArtifact, VideoArtifact
+from agno.media import Audio, File, Image, Video
 from agno.models.message import Citations, Message
 from agno.models.metrics import Metrics
 from agno.models.response import ToolExecution
@@ -98,8 +98,8 @@ class RunContentEvent(BaseTeamRunEvent):
     content_type: str = "str"
     reasoning_content: Optional[str] = None
     citations: Optional[Citations] = None
-    response_audio: Optional[AudioResponse] = None  # Model audio response
-    image: Optional[ImageArtifact] = None  # Image attached to the response
+    response_audio: Optional[Audio] = None  # Model audio response
+    image: Optional[Image] = None  # Image attached to the response
     references: Optional[List[MessageReferences]] = None
     additional_input: Optional[List[Message]] = None
     reasoning_steps: Optional[List[ReasoningStep]] = None
@@ -120,10 +120,10 @@ class RunCompletedEvent(BaseTeamRunEvent):
     content_type: str = "str"
     reasoning_content: Optional[str] = None
     citations: Optional[Citations] = None
-    images: Optional[List[ImageArtifact]] = None  # Images attached to the response
-    videos: Optional[List[VideoArtifact]] = None  # Videos attached to the response
-    audio: Optional[List[AudioArtifact]] = None  # Audio attached to the response
-    response_audio: Optional[AudioResponse] = None  # Model audio response
+    images: Optional[List[Image]] = None  # Images attached to the response
+    videos: Optional[List[Video]] = None  # Videos attached to the response
+    audio: Optional[List[Audio]] = None  # Audio attached to the response
+    response_audio: Optional[Audio] = None  # Model audio response
     references: Optional[List[MessageReferences]] = None
     additional_input: Optional[List[Message]] = None
     reasoning_steps: Optional[List[ReasoningStep]] = None
@@ -190,9 +190,9 @@ class ToolCallCompletedEvent(BaseTeamRunEvent):
     event: str = TeamRunEvent.tool_call_completed.value
     tool: Optional[ToolExecution] = None
     content: Optional[Any] = None
-    images: Optional[List[ImageArtifact]] = None  # Images produced by the tool call
-    videos: Optional[List[VideoArtifact]] = None  # Videos produced by the tool call
-    audio: Optional[List[AudioArtifact]] = None  # Audio produced by the tool call
+    images: Optional[List[Image]] = None  # Images produced by the tool call
+    videos: Optional[List[Video]] = None  # Videos produced by the tool call
+    audio: Optional[List[Audio]] = None  # Audio produced by the tool call
 
 
 @dataclass
@@ -289,9 +289,9 @@ class TeamRunInput:
     """
 
     input_content: Optional[Union[str, List, Dict, Message, BaseModel, List[Message]]] = None
-    images: Optional[Sequence[ImageArtifact]] = None
-    videos: Optional[Sequence[VideoArtifact]] = None
-    audios: Optional[Sequence[AudioArtifact]] = None
+    images: Optional[Sequence[Image]] = None
+    videos: Optional[Sequence[Video]] = None
+    audios: Optional[Sequence[Audio]] = None
     files: Optional[Sequence[File]] = None
 
     def to_dict(self) -> Dict[str, Any]:
@@ -328,15 +328,15 @@ class TeamRunInput:
         """Create TeamRunInput from dictionary"""
         images = None
         if data.get("images"):
-            images = [ImageArtifact.model_validate(img_data) for img_data in data["images"]]
+            images = [Image.model_validate(img_data) for img_data in data["images"]]
 
         videos = None
         if data.get("videos"):
-            videos = [VideoArtifact.model_validate(vid_data) for vid_data in data["videos"]]
+            videos = [Video.model_validate(vid_data) for vid_data in data["videos"]]
 
         audios = None
         if data.get("audios"):
-            audios = [AudioArtifact.model_validate(aud_data) for aud_data in data["audios"]]
+            audios = [Audio.model_validate(aud_data) for aud_data in data["audios"]]
 
         files = None
         if data.get("files"):
@@ -366,11 +366,11 @@ class TeamRunOutput:
 
     tools: Optional[List[ToolExecution]] = None
 
-    images: Optional[List[ImageArtifact]] = None  # Images from member runs
-    videos: Optional[List[VideoArtifact]] = None  # Videos from member runs
-    audio: Optional[List[AudioArtifact]] = None  # Audio from member runs
+    images: Optional[List[Image]] = None  # Images from member runs
+    videos: Optional[List[Video]] = None  # Videos from member runs
+    audio: Optional[List[Audio]] = None  # Audio from member runs
 
-    response_audio: Optional[AudioResponse] = None  # Model audio response
+    response_audio: Optional[Audio] = None  # Model audio response
 
     # Input media and messages from user
     input: Optional[TeamRunInput] = None
@@ -539,19 +539,19 @@ class TeamRunOutput:
             references = [MessageReferences.model_validate(reference) for reference in references]
 
         images = data.pop("images", [])
-        images = [ImageArtifact.model_validate(image) for image in images] if images else None
+        images = [Image.model_validate(image) for image in images] if images else None
 
         videos = data.pop("videos", [])
-        videos = [VideoArtifact.model_validate(video) for video in videos] if videos else None
+        videos = [Video.model_validate(video) for video in videos] if videos else None
 
         audio = data.pop("audio", [])
-        audio = [AudioArtifact.model_validate(audio) for audio in audio] if audio else None
+        audio = [Audio.model_validate(audio) for audio in audio] if audio else None
 
         tools = data.pop("tools", [])
         tools = [ToolExecution.from_dict(tool) for tool in tools] if tools else None
 
         response_audio = data.pop("response_audio", None)
-        response_audio = AudioResponse.model_validate(response_audio) if response_audio else None
+        response_audio = Audio.model_validate(response_audio) if response_audio else None
 
         input_data = data.pop("input", None)
         input_obj = None

agno/run/workflow.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 from pydantic import BaseModel
 
-from agno.media import AudioArtifact, AudioResponse, ImageArtifact, VideoArtifact
+from agno.media import Audio, Image, Video
 from agno.run.agent import RunOutput
 from agno.run.base import RunStatus
 from agno.run.team import TeamRunOutput
@@ -182,10 +182,10 @@ class StepCompletedEvent(BaseWorkflowRunOutputEvent):
     content_type: str = "str"
 
     # Media content fields
-    images: Optional[List[ImageArtifact]] = None
-    videos: Optional[List[VideoArtifact]] = None
-    audio: Optional[List[AudioArtifact]] = None
-    response_audio: Optional[AudioResponse] = None
+    images: Optional[List[Image]] = None
+    videos: Optional[List[Video]] = None
+    audio: Optional[List[Audio]] = None
+    response_audio: Optional[Audio] = None
 
     # Store actual step execution results as StepOutput objects
     step_response: Optional[StepOutput] = None
@@ -361,15 +361,15 @@ class StepOutputEvent(BaseWorkflowRunOutputEvent):
         return self.step_output.content if self.step_output else None
 
     @property
-    def images(self) -> Optional[List[ImageArtifact]]:
+    def images(self) -> Optional[List[Image]]:
         return self.step_output.images if self.step_output else None
 
     @property
-    def videos(self) -> Optional[List[VideoArtifact]]:
+    def videos(self) -> Optional[List[Video]]:
         return self.step_output.videos if self.step_output else None
 
     @property
-    def audio(self) -> Optional[List[AudioArtifact]]:
+    def audio(self) -> Optional[List[Audio]]:
         return self.step_output.audio if self.step_output else None
 
     @property
@@ -433,10 +433,10 @@ class WorkflowRunOutput:
     session_id: Optional[str] = None
 
     # Media content fields
-    images: Optional[List[ImageArtifact]] = None
-    videos: Optional[List[VideoArtifact]] = None
-    audio: Optional[List[AudioArtifact]] = None
-    response_audio: Optional[AudioResponse] = None
+    images: Optional[List[Image]] = None
+    videos: Optional[List[Video]] = None
+    audio: Optional[List[Audio]] = None
+    response_audio: Optional[Audio] = None
 
     # Store actual step execution results as StepOutput objects
     step_results: List[Union[StepOutput, List[StepOutput]]] = field(default_factory=list)
@@ -554,16 +554,16 @@ class WorkflowRunOutput:
         metadata = data.pop("metadata", None)
 
         images = data.pop("images", [])
-        images = [ImageArtifact.model_validate(image) for image in images] if images else None
+        images = [Image.model_validate(image) for image in images] if images else None
 
         videos = data.pop("videos", [])
-        videos = [VideoArtifact.model_validate(video) for video in videos] if videos else None
+        videos = [Video.model_validate(video) for video in videos] if videos else None
 
         audio = data.pop("audio", [])
-        audio = [AudioArtifact.model_validate(audio) for audio in audio] if audio else None
+        audio = [Audio.model_validate(audio) for audio in audio] if audio else None
 
         response_audio = data.pop("response_audio", None)
-        response_audio = AudioResponse.model_validate(response_audio) if response_audio else None
+        response_audio = Audio.model_validate(response_audio) if response_audio else None
 
         events = data.pop("events", [])
 

agno/team/team.py

@@ -33,7 +33,7 @@ from agno.agent import Agent
 from agno.db.base import BaseDb, SessionType, UserMemory
 from agno.exceptions import ModelProviderError, RunCancelledException
 from agno.knowledge.knowledge import Knowledge
-from agno.media import Audio, AudioArtifact, AudioResponse, File, Image, ImageArtifact, Video, VideoArtifact
+from agno.media import Audio, File, Image, Video
 from agno.memory import MemoryManager
 from agno.models.base import Model
 from agno.models.message import Message, MessageReferences
@@ -546,11 +546,11 @@ class Team:
 
         # TODO: Remove these
         # Images generated during this session
-        self.images: Optional[List[ImageArtifact]] = None
+        self.images: Optional[List[Image]] = None
         # Audio generated during this session
-        self.audio: Optional[List[AudioArtifact]] = None
+        self.audio: Optional[List[Audio]] = None
         # Videos generated during this session
-        self.videos: Optional[List[VideoArtifact]] = None
+        self.videos: Optional[List[Video]] = None
 
         # Team session
         self._team_session: Optional[TeamSession] = None
@@ -1119,7 +1119,7 @@ class Team:
         # Initialize Team
         self.initialize_team(debug_mode=debug_mode)
 
-        image_artifacts, video_artifacts, audio_artifacts = self._convert_media_to_artifacts(
+        image_artifacts, video_artifacts, audio_artifacts = self._validate_media_object_id(
             images=images, videos=videos, audios=audio
         )
 
@@ -1661,7 +1661,7 @@ class Team:
         # Initialize Team
         self.initialize_team(debug_mode=debug_mode)
 
-        image_artifacts, video_artifacts, audio_artifacts = self._convert_media_to_artifacts(
+        image_artifacts, video_artifacts, audio_artifacts = self._validate_media_object_id(
             images=images, videos=videos, audios=audio
         )
 
@@ -2155,28 +2155,38 @@ class Team:
                     should_yield = True
 
                 # Process thinking
-                if model_response_event.reasoning_content is not None:
-                    if not full_model_response.reasoning_content:
-                        full_model_response.reasoning_content = model_response_event.reasoning_content
-                    else:
-                        full_model_response.reasoning_content += model_response_event.reasoning_content
-                    should_yield = True
-
-                if model_response_event.citations is not None:
-                    # We get citations in one chunk
-                    full_model_response.citations = model_response_event.citations
-                    should_yield = True
-
-                # Process audio
                 if model_response_event.audio is not None:
                     if full_model_response.audio is None:
-                        full_model_response.audio = AudioResponse(id=str(uuid4()), content="", transcript="")
+                        full_model_response.audio = Audio(id=str(uuid4()), content=b"", transcript="")
 
                     if model_response_event.audio.id is not None:
                         full_model_response.audio.id = model_response_event.audio.id  # type: ignore
+
                     if model_response_event.audio.content is not None:
-                        full_model_response.audio.content += model_response_event.audio.content  # type: ignore
+                        # Handle both base64 string and bytes content
+                        if isinstance(model_response_event.audio.content, str):
+                            # Decode base64 string to bytes
+                            try:
+                                import base64
+
+                                decoded_content = base64.b64decode(model_response_event.audio.content)
+                                if full_model_response.audio.content is None:
+                                    full_model_response.audio.content = b""
+                                full_model_response.audio.content += decoded_content
+                            except Exception:
+                                # If decode fails, encode string as bytes
+                                if full_model_response.audio.content is None:
+                                    full_model_response.audio.content = b""
+                                full_model_response.audio.content += model_response_event.audio.content.encode("utf-8")
+                        elif isinstance(model_response_event.audio.content, bytes):
+                            # Content is already bytes
+                            if full_model_response.audio.content is None:
+                                full_model_response.audio.content = b""
+                            full_model_response.audio.content += model_response_event.audio.content
+
                     if model_response_event.audio.transcript is not None:
+                        if full_model_response.audio.transcript is None:
+                            full_model_response.audio.transcript = ""
                         full_model_response.audio.transcript += model_response_event.audio.transcript  # type: ignore
                     if model_response_event.audio.expires_at is not None:
                         full_model_response.audio.expires_at = model_response_event.audio.expires_at  # type: ignore
@@ -3021,63 +3031,43 @@ class Team:
         message.image_output = None
         message.video_output = None
 
-    def _convert_media_to_artifacts(
+    def _validate_media_object_id(
         self,
         images: Optional[Sequence[Image]] = None,
         videos: Optional[Sequence[Video]] = None,
         audios: Optional[Sequence[Audio]] = None,
     ) -> tuple:
-        """Convert raw Image/Video/Audio objects to ImageArtifact/VideoArtifact/AudioArtifact objects."""
-        from uuid import uuid4
-
-        from agno.media import AudioArtifact, ImageArtifact, VideoArtifact
-
-        image_artifacts = None
+        image_list = None
         if images:
-            image_artifacts = []
+            image_list = []
             for img in images:
-                try:
-                    artifact_id = img.id if hasattr(img, "id") and img.id else str(uuid4())
+                if not img.id:
+                    from uuid import uuid4
 
-                    if img.url:
-                        image_artifacts.append(ImageArtifact(id=artifact_id, url=img.url))
-                    elif img.content:
-                        image_artifacts.append(ImageArtifact(id=artifact_id, content=img.content))
-                except Exception as e:
-                    log_warning(f"Error creating ImageArtifact: {e}")
-                    continue
+                    img.id = str(uuid4())
+                image_list.append(img)
 
-        video_artifacts = None
+        video_list = None
         if videos:
-            video_artifacts = []
+            video_list = []
             for vid in videos:
-                try:
-                    artifact_id = vid.id if hasattr(vid, "id") and vid.id else str(uuid4())
+                if not vid.id:
+                    from uuid import uuid4
 
-                    if vid.url:
-                        video_artifacts.append(VideoArtifact(id=artifact_id, url=vid.url))
-                    elif vid.content:
-                        video_artifacts.append(VideoArtifact(id=artifact_id, content=vid.content))
-                except Exception as e:
-                    log_warning(f"Error creating VideoArtifact: {e}")
-                    continue
+                    vid.id = str(uuid4())
+                video_list.append(vid)
 
-        audio_artifacts = None
+        audio_list = None
         if audios:
-            audio_artifacts = []
+            audio_list = []
             for aud in audios:
-                try:
-                    artifact_id = aud.id if hasattr(aud, "id") and aud.id else str(uuid4())
+                if not aud.id:
+                    from uuid import uuid4
 
-                    if aud.url:
-                        audio_artifacts.append(AudioArtifact(id=artifact_id, url=aud.url))
-                    elif aud.content:
-                        audio_artifacts.append(AudioArtifact(id=artifact_id, base64_audio=aud.content))
-                except Exception as e:
-                    log_warning(f"Error creating AudioArtifact: {e}")
-                    continue
+                    aud.id = str(uuid4())
+                audio_list.append(aud)
 
-        return image_artifacts, video_artifacts, audio_artifacts
+        return image_list, video_list, audio_list
 
     def cli_app(
         self,
@@ -3754,19 +3744,11 @@ class Team:
         session: Optional[TeamSession] = None,
     ) -> Optional[Sequence[Image]]:
         """Collect images from input, session history, and current run response."""
-        joint_images = []
+        joint_images: List[Image] = []
 
         # 1. Add images from current input
         if run_input and run_input.images:
-            for artifact in run_input.images:
-                try:
-                    if artifact.url:
-                        joint_images.append(Image(url=artifact.url))
-                    elif artifact.content:
-                        joint_images.append(Image(content=artifact.content))
-                except Exception as e:
-                    log_warning(f"Error converting ImageArtifact to Image: {e}")
-                    continue
+            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)
@@ -3775,30 +3757,14 @@ class Team:
                 for historical_run in session.runs:
                     # Add generated images from previous runs
                     if historical_run.images:
-                        for artifact in historical_run.images:
-                            try:
-                                if artifact.url:
-                                    joint_images.append(Image(url=artifact.url))
-                                elif artifact.content:
-                                    joint_images.append(Image(content=artifact.content))
-                            except Exception as e:
-                                log_warning(f"Error converting historical ImageArtifact to Image: {e}")
-                                continue
+                        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:
-                        for artifact in historical_run.input.images:
-                            try:
-                                if artifact.url:
-                                    joint_images.append(Image(url=artifact.url))
-                                elif artifact.content:
-                                    joint_images.append(Image(content=artifact.content))
-                            except Exception as e:
-                                log_warning(f"Error converting input ImageArtifact to Image: {e}")
-                                continue
+                        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}"
                         )
@@ -3815,19 +3781,11 @@ class Team:
         session: Optional[TeamSession] = None,
     ) -> Optional[Sequence[Video]]:
         """Collect videos from input, session history, and current run response."""
-        joint_videos = []
+        joint_videos: List[Video] = []
 
         # 1. Add videos from current input
         if run_input and run_input.videos:
-            for artifact in run_input.videos:
-                try:
-                    if artifact.url:
-                        joint_videos.append(Video(url=artifact.url))
-                    elif artifact.content:
-                        joint_videos.append(Video(content=artifact.content))
-                except Exception as e:
-                    log_warning(f"Error converting VideoArtifact to Video: {e}")
-                    continue
+            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)
@@ -3836,30 +3794,14 @@ class Team:
                 for historical_run in session.runs:
                     # Add generated videos from previous runs
                     if historical_run.videos:
-                        for artifact in historical_run.videos:
-                            try:
-                                if artifact.url:
-                                    joint_videos.append(Video(url=artifact.url))
-                                elif artifact.content:
-                                    joint_videos.append(Video(content=artifact.content))
-                            except Exception as e:
-                                log_warning(f"Error converting historical VideoArtifact to Video: {e}")
-                                continue
+                        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:
-                        for artifact in historical_run.input.videos:
-                            try:
-                                if artifact.url:
-                                    joint_videos.append(Video(url=artifact.url))
-                                elif artifact.content:
-                                    joint_videos.append(Video(content=artifact.content))
-                            except Exception as e:
-                                log_warning(f"Error converting input VideoArtifact to Video: {e}")
-                                continue
+                        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}"
                         )
@@ -3876,19 +3818,11 @@ class Team:
         session: Optional[TeamSession] = None,
     ) -> Optional[Sequence[Audio]]:
         """Collect audios from input, session history, and current run response."""
-        joint_audios = []
+        joint_audios: List[Audio] = []
 
         # 1. Add audios from current input
         if run_input and run_input.audios:
-            for artifact in run_input.audios:
-                try:
-                    if artifact.url:
-                        joint_audios.append(Audio(url=artifact.url))
-                    elif artifact.base64_audio:
-                        joint_audios.append(Audio(content=artifact.base64_audio))
-                except Exception as e:
-                    log_warning(f"Error converting AudioArtifact to Audio: {e}")
-                    continue
+            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)
@@ -3897,30 +3831,14 @@ class Team:
                 for historical_run in session.runs:
                     # Add generated audios from previous runs
                     if historical_run.audio:
-                        for artifact in historical_run.audio:
-                            try:
-                                if artifact.url:
-                                    joint_audios.append(Audio(url=artifact.url))
-                                elif artifact.base64_audio:
-                                    joint_audios.append(Audio(content=artifact.base64_audio))
-                            except Exception as e:
-                                log_warning(f"Error converting historical AudioArtifact to Audio: {e}")
-                                continue
+                        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:
-                        for artifact in historical_run.input.audios:
-                            try:
-                                if artifact.url:
-                                    joint_audios.append(Audio(url=artifact.url))
-                                elif artifact.base64_audio:
-                                    joint_audios.append(Audio(content=artifact.base64_audio))
-                            except Exception as e:
-                                log_warning(f"Error converting input AudioArtifact to Audio: {e}")
-                                continue
+                        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}"
                         )
@@ -5114,11 +5032,11 @@ class Team:
         if self.share_member_interactions:
             team_member_interactions_str = self._get_team_member_interactions_str(team_run_context=team_run_context)  # type: ignore
             if context_images := self._get_team_run_context_images(team_run_context=team_run_context):  # type: ignore
-                images.extend([Image.from_artifact(img) for img in context_images])
+                images.extend(context_images)
             if context_videos := self._get_team_run_context_videos(team_run_context=team_run_context):  # type: ignore
-                videos.extend([Video.from_artifact(vid) for vid in context_videos])
+                videos.extend(context_videos)
             if context_audio := self._get_team_run_context_audio(team_run_context=team_run_context):  # type: ignore
-                audio.extend([Audio.from_artifact(aud) for aud in context_audio])
+                audio.extend(context_audio)
         return team_member_interactions_str
 
     def _find_member_by_id(self, member_id: str) -> Optional[Tuple[int, Union[Agent, "Team"]]]:
@@ -6188,7 +6106,7 @@ class Team:
             team_member_interactions_str += "</member interactions>\n"
         return team_member_interactions_str
 
-    def _get_team_run_context_images(self, team_run_context: Dict[str, Any]) -> List[ImageArtifact]:
+    def _get_team_run_context_images(self, team_run_context: Dict[str, Any]) -> List[Image]:
         if not team_run_context:
             return []
         images = []
@@ -6198,7 +6116,7 @@ class Team:
                     images.extend(interaction["run_response"].images)
         return images
 
-    def _get_team_run_context_videos(self, team_run_context: Dict[str, Any]) -> List[VideoArtifact]:
+    def _get_team_run_context_videos(self, team_run_context: Dict[str, Any]) -> List[Video]:
         if not team_run_context:
             return []
         videos = []
@@ -6208,7 +6126,7 @@ class Team:
                     videos.extend(interaction["run_response"].videos)
         return videos
 
-    def _get_team_run_context_audio(self, team_run_context: Dict[str, Any]) -> List[AudioArtifact]:
+    def _get_team_run_context_audio(self, team_run_context: Dict[str, Any]) -> List[Audio]:
         if not team_run_context:
             return []
         audio = []
@@ -6222,21 +6140,21 @@ class Team:
     # Handle images, videos and audio
     ###########################################################################
 
-    def _add_image(self, image: ImageArtifact, run_response: TeamRunOutput) -> None:
+    def _add_image(self, image: Image, run_response: TeamRunOutput) -> None:
         """Add an image to both the agent's stateful storage and the current run response"""
         # Add to run response
         if run_response.images is None:
             run_response.images = []
         run_response.images.append(image)
 
-    def _add_video(self, video: VideoArtifact, run_response: TeamRunOutput) -> None:
+    def _add_video(self, video: Video, run_response: TeamRunOutput) -> None:
         """Add a video to both the agent's stateful storage and the current run response"""
         # Add to run response
         if run_response.videos is None:
             run_response.videos = []
         run_response.videos.append(video)
 
-    def _add_audio(self, audio: AudioArtifact, run_response: TeamRunOutput) -> None:
+    def _add_audio(self, audio: Audio, run_response: TeamRunOutput) -> None:
         """Add audio to both the agent's stateful storage and the current run response"""
         # Add to run response
         if run_response.audio is None:

agno/tools/brightdata.py

@@ -5,7 +5,7 @@ from typing import Any, Dict, List, Optional
 from uuid import uuid4
 
 from agno.agent import Agent
-from agno.media import ImageArtifact
+from agno.media import Image
 from agno.tools import Toolkit
 from agno.tools.function import ToolResult
 from agno.utils.log import log_debug, log_error, log_info
@@ -158,8 +158,8 @@ class BrightDataTools(Toolkit):
 
             media_id = str(uuid4())
 
-            # Create ImageArtifact for the screenshot
-            image_artifact = ImageArtifact(
+            # Create Image for the screenshot
+            image_artifact = Image(
                 id=media_id,
                 content=base64_encoded_image.encode("utf-8"),
                 mime_type="image/png",

agno/tools/cartesia.py

@@ -1,11 +1,10 @@
 import json
-from base64 import b64encode
 from os import getenv
 from typing import Any, Dict, List, Optional, Union
 from uuid import uuid4
 
 from agno.agent import Agent
-from agno.media import AudioArtifact
+from agno.media import Audio
 from agno.team.team import Team
 from agno.tools import Toolkit
 from agno.tools.function import ToolResult
@@ -170,12 +169,11 @@ class CartesiaTools(Toolkit):
 
             audio_iterator = self.client.tts.bytes(**params)
             audio_data = b"".join(chunk for chunk in audio_iterator)
-            base64_audio = b64encode(audio_data).decode("utf-8")
 
             # Create AudioArtifact
-            audio_artifact = AudioArtifact(
+            audio_artifact = Audio(
                 id=str(uuid4()),
-                base64_audio=base64_audio,
+                content=audio_data,
                 mime_type=mime_type,  # Hardcoded to audio/mpeg
             )