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

agno/run/base.py

@@ -1,17 +1,29 @@
 from dataclasses import asdict, dataclass
 from enum import Enum
-from typing import Any, Dict
+from typing import Any, Dict, List, Optional, Union
 
 from pydantic import BaseModel
 
-from agno.media import AudioArtifact, AudioResponse, ImageArtifact, VideoArtifact
+from agno.filters import FilterExpr
+from agno.media import Audio, Image, Video
 from agno.models.message import Citations, Message, MessageReferences
 from agno.models.metrics import Metrics
-from agno.models.response import ToolExecution
 from agno.reasoning.step import ReasoningStep
 from agno.utils.log import log_error
 
 
+@dataclass
+class RunContext:
+    run_id: str
+    session_id: str
+    user_id: Optional[str] = None
+
+    dependencies: Optional[Dict[str, Any]] = None
+    knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
+    metadata: Optional[Dict[str, Any]] = None
+    session_state: Optional[Dict[str, Any]] = None
+
+
 @dataclass
 class BaseRunOutputEvent:
     def to_dict(self) -> Dict[str, Any]:
@@ -35,6 +47,7 @@ class BaseRunOutputEvent:
                 "reasoning_steps",
                 "references",
                 "additional_input",
+                "session_summary",
                 "metrics",
             ]
         }
@@ -60,21 +73,15 @@ class BaseRunOutputEvent:
         if hasattr(self, "images") and self.images is not None:
             _dict["images"] = []
             for img in self.images:
-                if isinstance(img, ImageArtifact):
+                if isinstance(img, Image):
                     _dict["images"].append(img.to_dict())
                 else:
                     _dict["images"].append(img)
 
-        if hasattr(self, "image") and self.image is not None:
-            if isinstance(self.image, ImageArtifact):
-                _dict["image"] = self.image.to_dict()
-            else:
-                _dict["image"] = self.image
-
         if hasattr(self, "videos") and self.videos is not None:
             _dict["videos"] = []
             for vid in self.videos:
-                if isinstance(vid, VideoArtifact):
+                if isinstance(vid, Video):
                     _dict["videos"].append(vid.to_dict())
                 else:
                     _dict["videos"].append(vid)
@@ -82,13 +89,13 @@ class BaseRunOutputEvent:
         if hasattr(self, "audio") and self.audio is not None:
             _dict["audio"] = []
             for aud in self.audio:
-                if isinstance(aud, AudioArtifact):
+                if isinstance(aud, Audio):
                     _dict["audio"].append(aud.to_dict())
                 else:
                     _dict["audio"].append(aud)
 
         if hasattr(self, "response_audio") and self.response_audio is not None:
-            if isinstance(self.response_audio, AudioResponse):
+            if isinstance(self.response_audio, Audio):
                 _dict["response_audio"] = self.response_audio.to_dict()
             else:
                 _dict["response_audio"] = self.response_audio
@@ -103,6 +110,8 @@ class BaseRunOutputEvent:
             _dict["content"] = self.content.model_dump(exclude_none=True)
 
         if hasattr(self, "tools") and self.tools is not None:
+            from agno.models.response import ToolExecution
+
             _dict["tools"] = []
             for tool in self.tools:
                 if isinstance(tool, ToolExecution):
@@ -111,6 +120,8 @@ class BaseRunOutputEvent:
                     _dict["tools"].append(tool)
 
         if hasattr(self, "tool") and self.tool is not None:
+            from agno.models.response import ToolExecution
+
             if isinstance(self.tool, ToolExecution):
                 _dict["tool"] = self.tool.to_dict()
             else:
@@ -119,44 +130,50 @@ class BaseRunOutputEvent:
         if hasattr(self, "metrics") and self.metrics is not None:
             _dict["metrics"] = self.metrics.to_dict()
 
+        if hasattr(self, "session_summary") and self.session_summary is not None:
+            _dict["session_summary"] = self.session_summary.to_dict()
+
         return _dict
 
-    def to_json(self) -> str:
+    def to_json(self, separators=(", ", ": "), indent: Optional[int] = 2) -> str:
         import json
 
+        from agno.utils.serialize import json_serializer
+
         try:
             _dict = self.to_dict()
         except Exception:
             log_error("Failed to convert response event to json", exc_info=True)
             raise
 
-        return json.dumps(_dict, indent=2)
+        if indent is None:
+            return json.dumps(_dict, separators=separators, default=json_serializer, ensure_ascii=False)
+        else:
+            return json.dumps(_dict, indent=indent, separators=separators, default=json_serializer, ensure_ascii=False)
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]):
         tool = data.pop("tool", None)
         if tool:
+            from agno.models.response import ToolExecution
+
             data["tool"] = ToolExecution.from_dict(tool)
 
         images = data.pop("images", None)
         if images:
-            data["images"] = [ImageArtifact.model_validate(image) for image in images]
-
-        image = data.pop("image", None)
-        if image:
-            data["image"] = ImageArtifact.model_validate(image)
+            data["images"] = [Image.model_validate(image) for image in images]
 
         videos = data.pop("videos", None)
         if videos:
-            data["videos"] = [VideoArtifact.model_validate(video) for video in videos]
+            data["videos"] = [Video.model_validate(video) for video in videos]
 
         audio = data.pop("audio", None)
         if audio:
-            data["audio"] = [AudioArtifact.model_validate(audio) for audio in audio]
+            data["audio"] = [Audio.model_validate(audio) for audio in audio]
 
         response_audio = data.pop("response_audio", None)
         if response_audio:
-            data["response_audio"] = AudioResponse.model_validate(response_audio)
+            data["response_audio"] = Audio.model_validate(response_audio)
 
         additional_input = data.pop("additional_input", None)
         if additional_input is not None:
@@ -178,7 +195,19 @@ class BaseRunOutputEvent:
         if metrics:
             data["metrics"] = Metrics(**metrics)
 
-        return cls(**data)
+        session_summary = data.pop("session_summary", None)
+        if session_summary:
+            from agno.session.summary import SessionSummary
+
+            data["session_summary"] = SessionSummary.from_dict(session_summary)
+
+        # Filter data to only include fields that are actually defined in the target class
+        from dataclasses import fields
+
+        supported_fields = {f.name for f in fields(cls)}
+        filtered_data = {k: v for k, v in data.items() if k in supported_fields}
+
+        return cls(**filtered_data)
 
     @property
     def is_paused(self):