agno 2.0.0a1__tar.gz → 2.0.0rc2__tar.gz

{agno-2.0.0a1 → agno-2.0.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 2.0.0a1
+Version: 2.0.0rc2
 Summary: Agno: a lightweight library for building Multi-Agent Systems
 Author-email: Ashpreet Bedi <ashpreet@agno.com>
 Project-URL: homepage, https://agno.com

{agno-2.0.0a1 → agno-2.0.0rc2}/agno/agent/agent.py

@@ -23,7 +23,7 @@ from typing import (
     get_args,
     overload,
 )
-from uuid import NAMESPACE_DNS, uuid4, uuid5
+from uuid import uuid4
 
 from pydantic import BaseModel
 
@@ -39,6 +39,7 @@ from agno.models.response import ModelResponse, ModelResponseEvent, ToolExecutio
 from agno.reasoning.step import NextAction, ReasoningStep, ReasoningSteps
 from agno.run.agent import (
     RunEvent,
+    RunInput,
     RunOutput,
     RunOutputEvent,
 )
@@ -128,10 +129,10 @@ class Agent:
     session_id: Optional[str] = None
     # Default session state (stored in the database to persist across runs)
     session_state: Optional[Dict[str, Any]] = None
-    # If True, the agent can update the session state
-    enable_agentic_state: bool = False
-    # If True, add the session state to the user prompt
+    # Set to True to add the session_state to the context
     add_session_state_to_context: bool = False
+    # Set to True to give the agent tools to update the session_state dynamically
+    enable_agentic_state: bool = False
     # If True, cache the current Agent session in memory for faster access
     cache_session: bool = False
 
@@ -222,6 +223,10 @@ class Agent:
     update_knowledge: bool = False
     # Add a tool that allows the Model to get the tool call history.
     read_tool_call_history: bool = False
+    # If False, media (images, videos, audio, files) is only available to tools and not sent to the LLM
+    send_media_to_model: bool = True
+    # If True, store media in run output
+    store_media: bool = True
 
     # --- System message settings ---
     # Provide the system message as a string or function
@@ -316,8 +321,6 @@ class Agent:
     # --- If this Agent is part of a workflow ---
     # Optional workflow ID. Indicates this agent is part of a workflow.
     workflow_id: Optional[str] = None
-    # Set when this agent is part of a workflow.
-    workflow_session_id: Optional[str] = None
 
     # Metadata stored with this agent
     metadata: Optional[Dict[str, Any]] = None
@@ -340,7 +343,6 @@ class Agent:
         id: Optional[str] = None,
         introduction: Optional[str] = None,
         user_id: Optional[str] = None,
-        app_id: Optional[str] = None,
         session_id: Optional[str] = None,
         session_state: Optional[Dict[str, Any]] = None,
         add_session_state_to_context: bool = False,
@@ -360,6 +362,7 @@ class Agent:
         session_summary_manager: Optional[SessionSummaryManager] = None,
         add_history_to_context: bool = False,
         num_history_runs: int = 3,
+        store_media: bool = True,
         knowledge: Optional[Knowledge] = None,
         knowledge_filters: Optional[Dict[str, Any]] = None,
         enable_agentic_knowledge_filters: Optional[bool] = None,
@@ -380,6 +383,7 @@ class Agent:
         search_knowledge: bool = True,
         update_knowledge: bool = False,
         read_tool_call_history: bool = False,
+        send_media_to_model: bool = True,
         system_message: Optional[Union[str, Callable, Message]] = None,
         system_message_role: str = "system",
         build_context: bool = True,
@@ -422,7 +426,6 @@ class Agent:
         self.id = id
         self.introduction = introduction
         self.user_id = user_id
-        self.app_id = app_id
 
         self.session_id = session_id
         self.session_state = session_state
@@ -450,6 +453,8 @@ class Agent:
         self.add_history_to_context = add_history_to_context
         self.num_history_runs = num_history_runs
 
+        self.store_media = store_media
+
         self.knowledge = knowledge
         self.knowledge_filters = knowledge_filters
         self.enable_agentic_knowledge_filters = enable_agentic_knowledge_filters
@@ -474,7 +479,7 @@ class Agent:
         self.search_knowledge = search_knowledge
         self.update_knowledge = update_knowledge
         self.read_tool_call_history = read_tool_call_history
-
+        self.send_media_to_model = send_media_to_model
         self.system_message = system_message
         self.system_message_role = system_message_role
         self.build_context = build_context
@@ -539,7 +544,7 @@ class Agent:
     def set_id(self) -> None:
         if self.id is None:
             if self.name is not None:
-                self.id = str(uuid5(NAMESPACE_DNS, self.name))
+                self.id = self.name.lower().replace(" ", "-")
             else:
                 self.id = str(uuid4())
 
@@ -584,6 +589,15 @@ class Agent:
         if isinstance(input, Message):
             input = input.content  # type: ignore
 
+        # If input is a string, convert it to a dict
+        if isinstance(input, str):
+            import json
+
+            try:
+                input = json.loads(input)
+            except Exception as e:
+                raise ValueError(f"Failed to parse input. Is it a valid JSON string?: {e}")
+
         # Case 1: Message is already a BaseModel instance
         if isinstance(input, BaseModel):
             if isinstance(input, self.input_schema):
@@ -760,6 +774,11 @@ class Agent:
         # 3. Update the RunOutput with the model response
         self._update_run_response(model_response=model_response, run_response=run_response, run_messages=run_messages)
 
+        if self.store_media:
+            self._store_media(run_response, model_response)
+        else:
+            self._scrub_media_from_run_output(run_response)
+
         # We should break out of the run function
         if any(tool_call.is_paused for tool_call in run_response.tools or []):
             return self._handle_agent_run_paused(
@@ -1059,6 +1078,15 @@ class Agent:
         # Initialize the Agent
         self.initialize_agent(debug_mode=debug_mode)
 
+        image_artifacts, video_artifacts, audio_artifacts = self._convert_media_to_artifacts(
+            images=images, videos=videos, audios=audio
+        )
+
+        # Create RunInput to capture the original user input
+        run_input = RunInput(
+            input_content=input, images=image_artifacts, videos=video_artifacts, audios=audio_artifacts, files=files
+        )
+
         # Read existing session from database
         agent_session = self._read_or_create_session(session_id=session_id, user_id=user_id)
         self._update_metadata(session=agent_session)
@@ -1128,6 +1156,7 @@ class Agent:
             agent_id=self.id,
             agent_name=self.name,
             metadata=metadata,
+            input=run_input,
         )
 
         run_response.model = self.model.id if self.model is not None else None
@@ -1305,6 +1334,11 @@ class Agent:
         # 3. Update the RunOutput with the model response
         self._update_run_response(model_response=model_response, run_response=run_response, run_messages=run_messages)
 
+        if self.store_media:
+            self._store_media(run_response, model_response)
+        else:
+            self._scrub_media_from_run_output(run_response)
+
         # We should break out of the run function
         if any(tool_call.is_paused for tool_call in run_response.tools or []):
             return self._handle_agent_run_paused(
@@ -1613,6 +1647,15 @@ class Agent:
         # Initialize the Agent
         self.initialize_agent(debug_mode=debug_mode)
 
+        image_artifacts, video_artifacts, audio_artifacts = self._convert_media_to_artifacts(
+            images=images, videos=videos, audios=audio
+        )
+
+        # Create RunInput to capture the original user input
+        run_input = RunInput(
+            input_content=input, images=image_artifacts, videos=video_artifacts, audios=audio_artifacts, files=files
+        )
+
         # Read existing session from storage
         agent_session = self._read_or_create_session(session_id=session_id, user_id=user_id)
         self._update_metadata(session=agent_session)
@@ -1679,6 +1722,7 @@ class Agent:
             agent_id=self.id,
             agent_name=self.name,
             metadata=metadata,
+            input=run_input,
         )
 
         run_response.model = self.model.id if self.model is not None else None
@@ -2942,6 +2986,21 @@ class Agent:
                 _t.requires_user_input = False
                 _t.answered = True
 
+    def _store_media(self, run_response: RunOutput, model_response: ModelResponse):
+        """Store media from model response in run_response for persistence"""
+        # Handle generated media fields from ModelResponse (generated media)
+        if model_response.images is not None:
+            for image in model_response.images:
+                self._add_image(image, run_response)  # Generated images go to run_response.images
+
+        if model_response.videos is not None:
+            for video in model_response.videos:
+                self._add_video(video, run_response)  # Generated videos go to run_response.videos
+
+        if model_response.audios is not None:
+            for audio in model_response.audios:
+                self._add_audio(audio, run_response)  # Generated audio go to run_response.audio
+
     def _update_run_response(self, model_response: ModelResponse, run_response: RunOutput, run_messages: RunMessages):
         # Handle structured outputs
         if self.output_schema is not None and model_response.parsed is not None:
@@ -2984,19 +3043,6 @@ class Agent:
                         run_response=run_response, tool_name=tool_name, tool_args=tool_args
                     )
 
-        # Handle unified media fields from ModelResponse
-        if model_response.images is not None:
-            for image in model_response.images:
-                self._add_image(image, run_response)
-
-        if model_response.videos is not None:
-            for video in model_response.videos:
-                self._add_video(video, run_response)
-
-        if model_response.audios is not None:
-            for audio in model_response.audios:
-                self._add_audio(audio, run_response)
-
         # Update the run_response audio with the model response audio
         if model_response.audio is not None:
             run_response.response_audio = model_response.audio
@@ -3190,6 +3236,12 @@ class Agent:
         if isinstance(model_response_event, tuple(get_args(RunOutputEvent))) or isinstance(
             model_response_event, tuple(get_args(TeamRunOutputEvent))
         ):
+            if model_response_event.event == RunEvent.custom_event:  # type: ignore
+                model_response_event.agent_id = self.id  # type: ignore
+                model_response_event.agent_name = self.name  # type: ignore
+                model_response_event.session_id = session.session_id  # type: ignore
+                model_response_event.run_id = run_response.run_id  # type: ignore
+
             # We just bubble the event up
             yield self._handle_event(model_response_event, run_response)  # type: ignore
         else:
@@ -3704,6 +3756,209 @@ class Agent:
 
         return agent_tools
 
+    def _collect_joint_images(
+        self,
+        run_input: Optional[RunInput] = None,
+        session: Optional[AgentSession] = None,
+    ) -> Optional[Sequence[Image]]:
+        """Collect images from input, session history, and current run response."""
+        joint_images = []
+
+        # 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
+            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:
+                        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
+                        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
+                        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(
+        self,
+        run_input: Optional[RunInput] = None,
+        session: Optional[AgentSession] = None,
+    ) -> Optional[Sequence[Video]]:
+        """Collect videos from input, session history, and current run response."""
+        joint_videos = []
+
+        # 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
+            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:
+                        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
+                        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
+                        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(
+        self,
+        run_input: Optional[RunInput] = None,
+        session: Optional[AgentSession] = None,
+    ) -> Optional[Sequence[Audio]]:
+        """Collect audios from input, session history, and current run response."""
+        joint_audios = []
+
+        # 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
+            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:
+                        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
+                        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
+                        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(
+        self,
+        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 _determine_tools_for_model(
         self,
         model: Model,
@@ -3802,8 +4057,27 @@ class Agent:
 
         # Update the session state for the functions
         if self._functions_for_model:
+            from inspect import signature
+
+            # Check if any functions need media before collecting
+            needs_media = any(
+                any(param in signature(func.entrypoint).parameters for param in ["images", "videos", "audios", "files"])
+                for func in self._functions_for_model.values()
+                if func.entrypoint is not None
+            )
+
+            # Only collect media if functions actually need them
+            joint_images = self._collect_joint_images(run_response.input, session) if needs_media else None
+            joint_files = self._collect_joint_files(run_response.input) if needs_media else None
+            joint_audios = self._collect_joint_audios(run_response.input, session) if needs_media else None
+            joint_videos = self._collect_joint_videos(run_response.input, session) if needs_media else None
+
             for func in self._functions_for_model.values():
                 func._session_state = session_state
+                func._images = joint_images
+                func._files = joint_files
+                func._audios = joint_audios
+                func._videos = joint_videos
 
     def _model_should_return_structured_output(self):
         self.model = cast(Model, self.model)
@@ -4102,7 +4376,7 @@ class Agent:
 
             return agent_session
 
-        log_warning(f"AgentSession {session_id_to_load} not found in db")
+        log_debug(f"AgentSession {session_id_to_load} not found in db")
         return None
 
     def save_session(self, session: AgentSession) -> None:
@@ -4656,10 +4930,10 @@ class Agent:
             return Message(
                 role=self.user_message_role,
                 content=input,
-                images=images,
-                audio=audio,
-                videos=videos,
-                files=files,
+                images=None if not self.send_media_to_model else images,
+                audio=None if not self.send_media_to_model else audio,
+                videos=None if not self.send_media_to_model else videos,
+                files=None if not self.send_media_to_model else files,
                 **kwargs,
             )
         # 2. Build the user message for the Agent
@@ -4669,10 +4943,10 @@ class Agent:
                 return Message(
                     role=self.user_message_role,
                     content="",
-                    images=images,
-                    audio=audio,
-                    videos=videos,
-                    files=files,
+                    images=None if not self.send_media_to_model else images,
+                    audio=None if not self.send_media_to_model else audio,
+                    videos=None if not self.send_media_to_model else videos,
+                    files=None if not self.send_media_to_model else files,
                     **kwargs,
                 )
             else:
@@ -4691,10 +4965,10 @@ class Agent:
                 return Message(
                     role=self.user_message_role,
                     content=message_content,
-                    images=images,
-                    audio=audio,
-                    videos=videos,
-                    files=files,
+                    images=None if not self.send_media_to_model else images,
+                    audio=None if not self.send_media_to_model else audio,
+                    videos=None if not self.send_media_to_model else videos,
+                    files=None if not self.send_media_to_model else files,
                     **kwargs,
                 )
 
@@ -4785,10 +5059,10 @@ class Agent:
                 return Message(
                     role=self.user_message_role,
                     content=user_msg_content,
-                    audio=audio,
-                    images=images,
-                    videos=videos,
-                    files=files,
+                    audio=None if not self.send_media_to_model else audio,
+                    images=None if not self.send_media_to_model else images,
+                    videos=None if not self.send_media_to_model else videos,
+                    files=None if not self.send_media_to_model else files,
                     **kwargs,
                 )
 
@@ -4836,7 +5110,7 @@ class Agent:
         )
         """
 
-        # Initialize the RunMessages object
+        # Initialize the RunMessages object (no media here - that's in RunInput now)
         run_messages = RunMessages()
 
         # 1. Add system message to run_messages
@@ -6578,6 +6852,7 @@ class Agent:
 
         if self.output_schema is not None:
             markdown = False
+            markdown = False
 
         if stream is None:
             stream = self.stream or False
@@ -6851,6 +7126,106 @@ class Agent:
 
         return effective_filters
 
+    def _scrub_media_from_run_output(self, run_response: RunOutput) -> 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 = []
+
+        # 2. RunOutput artifact media are skipped since we don't store them when store_media=False
+
+        # 3. Scrub media from all messages
+        if run_response.messages:
+            for message in run_response.messages:
+                self._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:
+                self._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:
+                self._scrub_media_from_message(message)
+
+    def _scrub_media_from_message(self, 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 _convert_media_to_artifacts(
+        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
+        if images:
+            image_artifacts = []
+            for img in images:
+                try:
+                    artifact_id = img.id if hasattr(img, "id") and img.id else str(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
+
+        video_artifacts = None
+        if videos:
+            video_artifacts = []
+            for vid in videos:
+                try:
+                    artifact_id = vid.id if hasattr(vid, "id") and vid.id else str(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
+
+        audio_artifacts = None
+        if audios:
+            audio_artifacts = []
+            for aud in audios:
+                try:
+                    artifact_id = aud.id if hasattr(aud, "id") and aud.id else str(uuid4())
+
+                    if aud.url:
+                        audio_artifacts.append(AudioArtifact(id=artifact_id, url=aud.url))
+                    elif aud.content:
+                        audio_artifacts.append(AudioArtifact(id=artifact_id, content=aud.content))
+                except Exception as e:
+                    log_warning(f"Error creating AudioArtifact: {e}")
+                    continue
+
+        return image_artifacts, video_artifacts, audio_artifacts
+
     def cli_app(
         self,
         input: Optional[str] = None,