agno 2.0.0rc1__py3-none-any.whl → 2.0.1__py3-none-any.whl

agno/agent/agent.py

@@ -30,7 +30,7 @@ from pydantic import BaseModel
 from agno.db.base import BaseDb, SessionType, UserMemory
 from agno.exceptions import ModelProviderError, RunCancelledException, StopAgentRun
 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
@@ -129,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
 
@@ -321,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
@@ -345,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,
@@ -429,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
@@ -593,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):
@@ -1073,7 +1078,7 @@ class Agent:
         # Initialize the Agent
         self.initialize_agent(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
         )
 
@@ -1642,7 +1647,7 @@ class Agent:
         # Initialize the Agent
         self.initialize_agent(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
         )
 
@@ -3231,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:
@@ -3309,23 +3320,47 @@ class Agent:
                 # Process audio
                 if model_response_event.audio is not None:
                     if model_response.audio is None:
-                        model_response.audio = AudioResponse(id=str(uuid4()), content="", transcript="")
+                        model_response.audio = Audio(id=str(uuid4()), content=b"", transcript="")
 
                     if model_response_event.audio.id is not None:
                         model_response.audio.id = model_response_event.audio.id  # type: ignore
+
                     if model_response_event.audio.content is not None:
-                        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 model_response.audio.content is None:
+                                    model_response.audio.content = b""
+                                model_response.audio.content += decoded_content
+                            except Exception:
+                                # If decode fails, encode string as bytes
+                                if model_response.audio.content is None:
+                                    model_response.audio.content = b""
+                                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 model_response.audio.content is None:
+                                model_response.audio.content = b""
+                            model_response.audio.content += model_response_event.audio.content
+
                     if model_response_event.audio.transcript is not None:
                         model_response.audio.transcript += model_response_event.audio.transcript  # type: ignore
+
                     if model_response_event.audio.expires_at is not None:
                         model_response.audio.expires_at = model_response_event.audio.expires_at  # type: ignore
                     if model_response_event.audio.mime_type is not None:
                         model_response.audio.mime_type = model_response_event.audio.mime_type  # type: ignore
-                    model_response.audio.sample_rate = model_response_event.audio.sample_rate
-                    model_response.audio.channels = model_response_event.audio.channels
+                    if model_response_event.audio.sample_rate is not None:
+                        model_response.audio.sample_rate = model_response_event.audio.sample_rate
+                    if model_response_event.audio.channels is not None:
+                        model_response.audio.channels = model_response_event.audio.channels
 
                     # Yield the audio and transcript bit by bit
-                    run_response.response_audio = AudioResponse(
+                    run_response.response_audio = Audio(
                         id=model_response_event.audio.id,
                         content=model_response_event.audio.content,
                         transcript=model_response_event.audio.transcript,
@@ -3353,6 +3388,14 @@ class Agent:
                         workflow_context=workflow_context,
                     )
 
+                    if model_response.images is None:
+                        model_response.images = []
+                    model_response.images.extend(model_response_event.images)
+                    # Store media in run_response if store_media is enabled
+                    if self.store_media:
+                        for image in model_response_event.images:
+                            self._add_image(image, run_response)
+
             # Handle tool interruption events
             elif model_response_event.event == ModelResponseEvent.tool_call_paused.value:
                 # Add tool calls to the run_response
@@ -3751,19 +3794,11 @@ class Agent:
         session: Optional[AgentSession] = 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)
@@ -3772,30 +3807,14 @@ class Agent:
                 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}"
                         )
@@ -3812,19 +3831,11 @@ class Agent:
         session: Optional[AgentSession] = 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)
@@ -3833,30 +3844,14 @@ class Agent:
                 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}"
                         )
@@ -3873,19 +3868,11 @@ class Agent:
         session: Optional[AgentSession] = 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)
@@ -3894,30 +3881,14 @@ class Agent:
                 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}"
                         )
@@ -4365,7 +4336,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:
@@ -5658,21 +5629,21 @@ class Agent:
     # Handle images, videos and audio
     ###########################################################################
 
-    def _add_image(self, image: ImageArtifact, run_response: RunOutput) -> None:
+    def _add_image(self, image: Image, run_response: RunOutput) -> 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: RunOutput) -> None:
+    def _add_video(self, video: Video, run_response: RunOutput) -> 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: RunOutput) -> None:
+    def _add_audio(self, audio: Audio, run_response: RunOutput) -> 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:
@@ -6841,6 +6812,7 @@ class Agent:
 
         if self.output_schema is not None:
             markdown = False
+            markdown = False
 
         if stream is None:
             stream = self.stream or False
@@ -7156,57 +7128,46 @@ class Agent:
         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
+        """Convert raw Image/Video/Audio objects - now unified, so just return as-is."""
+        # With unified classes, no conversion needed - just ensure IDs are set
+        image_list = None
         if images:
-            image_artifacts = []
+            image_list = []
             for img in images:
-                try:
-                    if img.url:
-                        image_artifacts.append(ImageArtifact(id=str(uuid4()), url=img.url))
-                    elif img.content:
-                        image_artifacts.append(ImageArtifact(id=str(uuid4()), content=img.content))
-                except Exception as e:
-                    log_warning(f"Error creating ImageArtifact: {e}")
-                    continue
+                # Ensure ID is set (validation should handle this, but double-check)
+                if not img.id:
+                    from uuid import uuid4
+
+                    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:
-                    if vid.url:
-                        video_artifacts.append(VideoArtifact(id=str(uuid4()), url=vid.url))
-                    elif vid.content:
-                        video_artifacts.append(VideoArtifact(id=str(uuid4()), content=vid.content))
-                except Exception as e:
-                    log_warning(f"Error creating VideoArtifact: {e}")
-                    continue
+                if not vid.id:
+                    from uuid import uuid4
 
-        audio_artifacts = None
+                    vid.id = str(uuid4())
+                video_list.append(vid)
+
+        audio_list = None
         if audios:
-            audio_artifacts = []
+            audio_list = []
             for aud in audios:
-                try:
-                    if aud.url:
-                        audio_artifacts.append(AudioArtifact(id=str(uuid4()), url=aud.url))
-                    elif aud.content:
-                        audio_artifacts.append(AudioArtifact(id=str(uuid4()), content=aud.content))
-                except Exception as e:
-                    log_warning(f"Error creating AudioArtifact: {e}")
-                    continue
+                if not aud.id:
+                    from uuid import uuid4
+
+                    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,

agno/db/mongo/mongo.py

@@ -672,7 +672,9 @@ class MongoDb(BaseDb):
             if result is None or not deserialize:
                 return result
 
-            return UserMemory.from_dict(result)
+            # Remove MongoDB's _id field before creating UserMemory object
+            result_filtered = {k: v for k, v in result.items() if k != "_id"}
+            return UserMemory.from_dict(result_filtered)
 
         except Exception as e:
             log_error(f"Exception reading from collection: {e}")
@@ -750,7 +752,8 @@ class MongoDb(BaseDb):
             if not deserialize:
                 return records, total_count
 
-            return [UserMemory.from_dict(record) for record in records]
+            # Remove MongoDB's _id field before creating UserMemory objects
+            return [UserMemory.from_dict({k: v for k, v in record.items() if k != "_id"}) for record in records]
 
         except Exception as e:
             log_error(f"Exception reading from collection: {e}")
@@ -861,7 +864,9 @@ class MongoDb(BaseDb):
             if not deserialize:
                 return update_doc
 
-            return UserMemory.from_dict(update_doc)
+            # Remove MongoDB's _id field before creating UserMemory object
+            update_doc_filtered = {k: v for k, v in update_doc.items() if k != "_id"}
+            return UserMemory.from_dict(update_doc_filtered)
 
         except Exception as e:
             log_error(f"Exception upserting user memory: {e}")

agno/eval/accuracy.py

@@ -97,11 +97,18 @@ class AccuracyResult:
             title_justify="center",
         )
         summary_table.add_row("Number of Runs", f"{len(self.results)}")
-        summary_table.add_row("Average Score", f"{self.avg_score:.2f}")
-        summary_table.add_row("Mean Score", f"{self.mean_score:.2f}")
-        summary_table.add_row("Minimum Score", f"{self.min_score:.2f}")
-        summary_table.add_row("Maximum Score", f"{self.max_score:.2f}")
-        summary_table.add_row("Standard Deviation", f"{self.std_dev_score:.2f}")
+
+        if self.avg_score is not None:
+            summary_table.add_row("Average Score", f"{self.avg_score:.2f}")
+        if self.mean_score is not None:
+            summary_table.add_row("Mean Score", f"{self.mean_score:.2f}")
+        if self.min_score is not None:
+            summary_table.add_row("Minimum Score", f"{self.min_score:.2f}")
+        if self.max_score is not None:
+            summary_table.add_row("Maximum Score", f"{self.max_score:.2f}")
+        if self.std_dev_score is not None:
+            summary_table.add_row("Standard Deviation", f"{self.std_dev_score:.2f}")
+
         console.print(summary_table)
 
     def print_results(self, console: Optional["Console"] = None):

agno/knowledge/chunking/strategy.py

@@ -35,13 +35,13 @@ class ChunkingStrategy(ABC):
 class ChunkingStrategyType(str, Enum):
     """Enumeration of available chunking strategies."""
 
-    AGENTIC_CHUNKING = "AgenticChunking"
-    DOCUMENT_CHUNKING = "DocumentChunking"
-    RECURSIVE_CHUNKING = "RecursiveChunking"
-    SEMANTIC_CHUNKING = "SemanticChunking"
-    FIXED_SIZE_CHUNKING = "FixedSizeChunking"
-    ROW_CHUNKING = "RowChunking"
-    MARKDOWN_CHUNKING = "MarkdownChunking"
+    AGENTIC_CHUNKER = "AgenticChunker"
+    DOCUMENT_CHUNKER = "DocumentChunker"
+    RECURSIVE_CHUNKER = "RecursiveChunker"
+    SEMANTIC_CHUNKER = "SemanticChunker"
+    FIXED_SIZE_CHUNKER = "FixedSizeChunker"
+    ROW_CHUNKER = "RowChunker"
+    MARKDOWN_CHUNKER = "MarkdownChunker"
 
     @classmethod
     def from_string(cls, strategy_name: str) -> "ChunkingStrategyType":
@@ -63,13 +63,13 @@ class ChunkingStrategyFactory:
     def create_strategy(cls, strategy_type: ChunkingStrategyType, **kwargs) -> ChunkingStrategy:
         """Create an instance of the chunking strategy with the given parameters."""
         strategy_map = {
-            ChunkingStrategyType.AGENTIC_CHUNKING: cls._create_agentic_chunking,
-            ChunkingStrategyType.DOCUMENT_CHUNKING: cls._create_document_chunking,
-            ChunkingStrategyType.RECURSIVE_CHUNKING: cls._create_recursive_chunking,
-            ChunkingStrategyType.SEMANTIC_CHUNKING: cls._create_semantic_chunking,
-            ChunkingStrategyType.FIXED_SIZE_CHUNKING: cls._create_fixed_chunking,
-            ChunkingStrategyType.ROW_CHUNKING: cls._create_row_chunking,
-            ChunkingStrategyType.MARKDOWN_CHUNKING: cls._create_markdown_chunking,
+            ChunkingStrategyType.AGENTIC_CHUNKER: cls._create_agentic_chunking,
+            ChunkingStrategyType.DOCUMENT_CHUNKER: cls._create_document_chunking,
+            ChunkingStrategyType.RECURSIVE_CHUNKER: cls._create_recursive_chunking,
+            ChunkingStrategyType.SEMANTIC_CHUNKER: cls._create_semantic_chunking,
+            ChunkingStrategyType.FIXED_SIZE_CHUNKER: cls._create_fixed_chunking,
+            ChunkingStrategyType.ROW_CHUNKER: cls._create_row_chunking,
+            ChunkingStrategyType.MARKDOWN_CHUNKER: cls._create_markdown_chunking,
         }
         return strategy_map[strategy_type](**kwargs)