agno 2.0.11__py3-none-any.whl → 2.1.1__py3-none-any.whl

agno/os/utils.py

@@ -1,6 +1,7 @@
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Set, Union
 
 from fastapi import FastAPI, HTTPException, UploadFile
+from fastapi.routing import APIRoute, APIRouter
 from starlette.middleware.cors import CORSMiddleware
 
 from agno.agent.agent import Agent
@@ -8,6 +9,7 @@ from agno.db.base import BaseDb
 from agno.knowledge.knowledge import Knowledge
 from agno.media import Audio, Image, Video
 from agno.media import File as FileMedia
+from agno.os.config import AgentOSConfig
 from agno.team.team import Team
 from agno.tools import Toolkit
 from agno.tools.function import Function
@@ -149,16 +151,16 @@ def process_document(file: UploadFile) -> Optional[FileMedia]:
 
 
 def extract_format(file: UploadFile):
-    format = None
+    _format = None
     if file.filename and "." in file.filename:
-        format = file.filename.split(".")[-1].lower()
+        _format = file.filename.split(".")[-1].lower()
     elif file.content_type:
-        format = file.content_type.split("/")[-1]
-    return format
+        _format = file.content_type.split("/")[-1]
+    return _format
 
 
 def format_tools(agent_tools: List[Union[Dict[str, Any], Toolkit, Function, Callable]]):
-    formatted_tools = []
+    formatted_tools: List[Dict] = []
     if agent_tools is not None:
         for tool in agent_tools:
             if isinstance(tool, dict):
@@ -284,7 +286,11 @@ def update_cors_middleware(app: FastAPI, new_origins: list):
     for middleware in app.user_middleware:
         if middleware.cls == CORSMiddleware:
             if hasattr(middleware, "kwargs"):
-                existing_origins = middleware.kwargs.get("allow_origins", [])
+                origins_value = middleware.kwargs.get("allow_origins", [])
+                if isinstance(origins_value, list):
+                    existing_origins = origins_value
+                else:
+                    existing_origins = []
             break
     # Merge origins
     merged_origins = list(set(new_origins + existing_origins))
@@ -296,7 +302,7 @@ def update_cors_middleware(app: FastAPI, new_origins: list):
 
     # Add updated CORS
     app.add_middleware(
-        CORSMiddleware,
+        CORSMiddleware,  # type: ignore
         allow_origins=final_origins,
         allow_credentials=True,
         allow_methods=["*"],
@@ -305,6 +311,66 @@ def update_cors_middleware(app: FastAPI, new_origins: list):
     )
 
 
+def get_existing_route_paths(fastapi_app: FastAPI) -> Dict[str, List[str]]:
+    """Get all existing route paths and methods from the FastAPI app.
+
+    Returns:
+        Dict[str, List[str]]: Dictionary mapping paths to list of HTTP methods
+    """
+    existing_paths: Dict[str, Any] = {}
+    for route in fastapi_app.routes:
+        if isinstance(route, APIRoute):
+            path = route.path
+            methods = list(route.methods) if route.methods else []
+            if path in existing_paths:
+                existing_paths[path].extend(methods)
+            else:
+                existing_paths[path] = methods
+    return existing_paths
+
+
+def find_conflicting_routes(fastapi_app: FastAPI, router: APIRouter) -> List[Dict[str, Any]]:
+    """Find conflicting routes in the FastAPI app.
+
+    Args:
+        fastapi_app: The FastAPI app with all existing routes
+        router: The APIRouter to add
+
+    Returns:
+        List[Dict[str, Any]]: List of conflicting routes
+    """
+    existing_paths = get_existing_route_paths(fastapi_app)
+
+    conflicts = []
+
+    for route in router.routes:
+        if isinstance(route, APIRoute):
+            full_path = route.path
+            route_methods = list(route.methods) if route.methods else []
+
+            if full_path in existing_paths:
+                conflicting_methods: Set[str] = set(route_methods) & set(existing_paths[full_path])
+                if conflicting_methods:
+                    conflicts.append({"path": full_path, "methods": list(conflicting_methods), "route": route})
+    return conflicts
+
+
+def load_yaml_config(config_file_path: str) -> AgentOSConfig:
+    """Load a YAML config file and return the configuration as an AgentOSConfig instance."""
+    from pathlib import Path
+
+    import yaml
+
+    # Validate that the path points to a YAML file
+    path = Path(config_file_path)
+    if path.suffix.lower() not in [".yaml", ".yml"]:
+        raise ValueError(f"Config file must have a .yaml or .yml extension, got: {config_file_path}")
+
+    # Load the YAML file
+    with open(config_file_path, "r") as f:
+        return AgentOSConfig.model_validate(yaml.safe_load(f))
+
+
 def collect_mcp_tools_from_team(team: Team, mcp_tools: List[Any]) -> None:
     """Recursively collect MCP tools from a team and its members."""
     # Check the team tools

agno/run/agent.py

@@ -14,6 +14,96 @@ from agno.run.base import BaseRunOutputEvent, MessageReferences, RunStatus
 from agno.utils.log import logger
 
 
+@dataclass
+class RunInput:
+    """Container for the raw input data passed to Agent.run().
+
+    This captures the original input exactly as provided by the user,
+    separate from the processed messages that go to the model.
+
+    Attributes:
+        input_content: The literal input message/content passed to run()
+        images: Images directly passed to run()
+        videos: Videos directly passed to run()
+        audios: Audio files directly passed to run()
+        files: Files directly passed to run()
+    """
+
+    input_content: Union[str, List, Dict, Message, BaseModel, List[Message]]
+    images: Optional[Sequence[Image]] = None
+    videos: Optional[Sequence[Video]] = None
+    audios: Optional[Sequence[Audio]] = None
+    files: Optional[Sequence[File]] = None
+
+    def input_content_string(self) -> str:
+        import json
+
+        if isinstance(self.input_content, (str)):
+            return self.input_content
+        elif isinstance(self.input_content, BaseModel):
+            return self.input_content.model_dump_json(exclude_none=True)
+        elif isinstance(self.input_content, Message):
+            return json.dumps(self.input_content.to_dict())
+        elif isinstance(self.input_content, list) and self.input_content and isinstance(self.input_content[0], Message):
+            return json.dumps([m.to_dict() for m in self.input_content])
+        else:
+            return str(self.input_content)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary representation"""
+        result: Dict[str, Any] = {}
+
+        if self.input_content is not None:
+            if isinstance(self.input_content, (str)):
+                result["input_content"] = self.input_content
+            elif isinstance(self.input_content, BaseModel):
+                result["input_content"] = self.input_content.model_dump(exclude_none=True)
+            elif isinstance(self.input_content, Message):
+                result["input_content"] = self.input_content.to_dict()
+            elif (
+                isinstance(self.input_content, list)
+                and self.input_content
+                and isinstance(self.input_content[0], Message)
+            ):
+                result["input_content"] = [m.to_dict() for m in self.input_content]
+            else:
+                result["input_content"] = self.input_content
+
+        if self.images:
+            result["images"] = [img.to_dict() for img in self.images]
+        if self.videos:
+            result["videos"] = [vid.to_dict() for vid in self.videos]
+        if self.audios:
+            result["audios"] = [aud.to_dict() for aud in self.audios]
+        if self.files:
+            result["files"] = [file.to_dict() for file in self.files]
+
+        return result
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "RunInput":
+        """Create RunInput from dictionary"""
+        images = None
+        if data.get("images"):
+            images = [Image.model_validate(img_data) for img_data in data["images"]]
+
+        videos = None
+        if data.get("videos"):
+            videos = [Video.model_validate(vid_data) for vid_data in data["videos"]]
+
+        audios = None
+        if data.get("audios"):
+            audios = [Audio.model_validate(aud_data) for aud_data in data["audios"]]
+
+        files = None
+        if data.get("files"):
+            files = [File.model_validate(file_data) for file_data in data["files"]]
+
+        return cls(
+            input_content=data.get("input_content", ""), images=images, videos=videos, audios=audios, files=files
+        )
+
+
 class RunEvent(str, Enum):
     """Events that can be sent by the run() functions"""
 
@@ -27,6 +117,9 @@ class RunEvent(str, Enum):
     run_paused = "RunPaused"
     run_continued = "RunContinued"
 
+    pre_hook_started = "PreHookStarted"
+    pre_hook_completed = "PreHookCompleted"
+
     tool_call_started = "ToolCallStarted"
     tool_call_completed = "ToolCallCompleted"
 
@@ -53,6 +146,7 @@ class BaseAgentRunEvent(BaseRunOutputEvent):
     agent_id: str = ""
     agent_name: str = ""
     run_id: Optional[str] = None
+    parent_run_id: Optional[str] = None
     session_id: Optional[str] = None
 
     # Step context for workflow execution
@@ -153,6 +247,11 @@ class RunErrorEvent(BaseAgentRunEvent):
     event: str = RunEvent.run_error.value
     content: Optional[str] = None
 
+    # From exceptions
+    error_type: Optional[str] = None
+    error_id: Optional[str] = None
+    additional_data: Optional[Dict[str, Any]] = None
+
 
 @dataclass
 class RunCancelledEvent(BaseAgentRunEvent):
@@ -164,6 +263,20 @@ class RunCancelledEvent(BaseAgentRunEvent):
         return True
 
 
+@dataclass
+class PreHookStartedEvent(BaseAgentRunEvent):
+    event: str = RunEvent.pre_hook_started.value
+    pre_hook_name: Optional[str] = None
+    run_input: Optional[RunInput] = None
+
+
+@dataclass
+class PreHookCompletedEvent(BaseAgentRunEvent):
+    event: str = RunEvent.pre_hook_completed.value
+    pre_hook_name: Optional[str] = None
+    run_input: Optional[RunInput] = None
+
+
 @dataclass
 class MemoryUpdateStartedEvent(BaseAgentRunEvent):
     event: str = RunEvent.memory_update_started.value
@@ -244,6 +357,8 @@ RunOutputEvent = Union[
     RunCancelledEvent,
     RunPausedEvent,
     RunContinuedEvent,
+    PreHookStartedEvent,
+    PreHookCompletedEvent,
     ReasoningStartedEvent,
     ReasoningStepEvent,
     ReasoningCompletedEvent,
@@ -269,6 +384,8 @@ RUN_EVENT_TYPE_REGISTRY = {
     RunEvent.run_cancelled.value: RunCancelledEvent,
     RunEvent.run_paused.value: RunPausedEvent,
     RunEvent.run_continued.value: RunContinuedEvent,
+    RunEvent.pre_hook_started.value: PreHookStartedEvent,
+    RunEvent.pre_hook_completed.value: PreHookCompletedEvent,
     RunEvent.reasoning_started.value: ReasoningStartedEvent,
     RunEvent.reasoning_step.value: ReasoningStepEvent,
     RunEvent.reasoning_completed.value: ReasoningCompletedEvent,
@@ -292,80 +409,6 @@ def run_output_event_from_dict(data: dict) -> BaseRunOutputEvent:
     return cls.from_dict(data)  # type: ignore
 
 
-@dataclass
-class RunInput:
-    """Container for the raw input data passed to Agent.run().
-
-    This captures the original input exactly as provided by the user,
-    separate from the processed messages that go to the model.
-
-    Attributes:
-        input_content: The literal input message/content passed to run()
-        images: Images directly passed to run()
-        videos: Videos directly passed to run()
-        audios: Audio files directly passed to run()
-        files: Files directly passed to run()
-    """
-
-    input_content: Optional[Union[str, List, Dict, Message, BaseModel, List[Message]]] = 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]:
-        """Convert to dictionary representation"""
-        result: Dict[str, Any] = {}
-
-        if self.input_content is not None:
-            if isinstance(self.input_content, (str)):
-                result["input_content"] = self.input_content
-            elif isinstance(self.input_content, BaseModel):
-                result["input_content"] = self.input_content.model_dump(exclude_none=True)
-            elif isinstance(self.input_content, Message):
-                result["input_content"] = self.input_content.to_dict()
-            elif (
-                isinstance(self.input_content, list)
-                and self.input_content
-                and isinstance(self.input_content[0], Message)
-            ):
-                result["input_content"] = [m.to_dict() for m in self.input_content]
-            else:
-                result["input_content"] = self.input_content
-
-        if self.images:
-            result["images"] = [img.to_dict() for img in self.images]
-        if self.videos:
-            result["videos"] = [vid.to_dict() for vid in self.videos]
-        if self.audios:
-            result["audios"] = [aud.to_dict() for aud in self.audios]
-        if self.files:
-            result["files"] = [file.to_dict() for file in self.files]
-
-        return result
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "RunInput":
-        """Create RunInput from dictionary"""
-        images = None
-        if data.get("images"):
-            images = [Image.model_validate(img_data) for img_data in data["images"]]
-
-        videos = None
-        if data.get("videos"):
-            videos = [Video.model_validate(vid_data) for vid_data in data["videos"]]
-
-        audios = None
-        if data.get("audios"):
-            audios = [Audio.model_validate(aud_data) for aud_data in data["audios"]]
-
-        files = None
-        if data.get("files"):
-            files = [File.model_validate(file_data) for file_data in data["files"]]
-
-        return cls(input_content=data.get("input_content"), images=images, videos=videos, audios=audios, files=files)
-
-
 @dataclass
 class RunOutput:
     """Response returned by Agent.run() or Workflow.run() functions"""
@@ -378,6 +421,9 @@ class RunOutput:
     workflow_id: Optional[str] = None
     user_id: Optional[str] = None
 
+    # Input media and messages from user
+    input: Optional[RunInput] = None
+
     content: Optional[Any] = None
     content_type: str = "str"
 
@@ -401,9 +447,6 @@ class RunOutput:
     files: Optional[List[File]] = None  # Files attached to the response
     response_audio: Optional[Audio] = None  # Model audio response
 
-    # Input media and messages from user
-    input: Optional[RunInput] = None
-
     citations: Optional[Citations] = None
     references: Optional[List[MessageReferences]] = None
 

agno/run/base.py

@@ -117,19 +117,8 @@ class BaseRunOutputEvent:
 
     def to_json(self, separators=(", ", ": "), indent: Optional[int] = 2) -> str:
         import json
-        from datetime import date, datetime, time
-        from enum import Enum
-
-        def json_serializer(obj):
-            # Datetime like
-            if isinstance(obj, (datetime, date, time)):
-                return obj.isoformat()
-            # Enums
-            if isinstance(obj, Enum):
-                v = obj.value
-                return v if isinstance(v, (str, int, float, bool, type(None))) else obj.name
-            # Fallback to string
-            return str(obj)
+
+        from agno.utils.serialize import json_serializer
 
         try:
             _dict = self.to_dict()

agno/run/team.py

@@ -15,6 +15,94 @@ from agno.run.base import BaseRunOutputEvent, MessageReferences, RunStatus
 from agno.utils.log import log_error
 
 
+@dataclass
+class TeamRunInput:
+    """Container for the raw input data passed to Agent.run().
+    This captures the original input exactly as provided by the user,
+    separate from the processed messages that go to the model.
+    Attributes:
+        input_content: The literal input message/content passed to run()
+        images: Images directly passed to run()
+        videos: Videos directly passed to run()
+        audios: Audio files directly passed to run()
+        files: Files directly passed to run()
+    """
+
+    input_content: Union[str, List, Dict, Message, BaseModel, List[Message]]
+    images: Optional[Sequence[Image]] = None
+    videos: Optional[Sequence[Video]] = None
+    audios: Optional[Sequence[Audio]] = None
+    files: Optional[Sequence[File]] = None
+
+    def input_content_string(self) -> str:
+        import json
+
+        if isinstance(self.input_content, (str)):
+            return self.input_content
+        elif isinstance(self.input_content, BaseModel):
+            return self.input_content.model_dump_json(exclude_none=True)
+        elif isinstance(self.input_content, Message):
+            return json.dumps(self.input_content.to_dict())
+        elif isinstance(self.input_content, list) and self.input_content and isinstance(self.input_content[0], Message):
+            return json.dumps([m.to_dict() for m in self.input_content])
+        else:
+            return str(self.input_content)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary representation"""
+        result: Dict[str, Any] = {}
+
+        if self.input_content is not None:
+            if isinstance(self.input_content, (str)):
+                result["input_content"] = self.input_content
+            elif isinstance(self.input_content, BaseModel):
+                result["input_content"] = self.input_content.model_dump(exclude_none=True)
+            elif isinstance(self.input_content, Message):
+                result["input_content"] = self.input_content.to_dict()
+            elif (
+                isinstance(self.input_content, list)
+                and self.input_content
+                and isinstance(self.input_content[0], Message)
+            ):
+                result["input_content"] = [m.to_dict() for m in self.input_content]
+            else:
+                result["input_content"] = self.input_content
+
+        if self.images:
+            result["images"] = [img.to_dict() for img in self.images]
+        if self.videos:
+            result["videos"] = [vid.to_dict() for vid in self.videos]
+        if self.audios:
+            result["audios"] = [aud.to_dict() for aud in self.audios]
+        if self.files:
+            result["files"] = [file.to_dict() for file in self.files]
+
+        return result
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "TeamRunInput":
+        """Create TeamRunInput from dictionary"""
+        images = None
+        if data.get("images"):
+            images = [Image.model_validate(img_data) for img_data in data["images"]]
+
+        videos = None
+        if data.get("videos"):
+            videos = [Video.model_validate(vid_data) for vid_data in data["videos"]]
+
+        audios = None
+        if data.get("audios"):
+            audios = [Audio.model_validate(aud_data) for aud_data in data["audios"]]
+
+        files = None
+        if data.get("files"):
+            files = [File.model_validate(file_data) for file_data in data["files"]]
+
+        return cls(
+            input_content=data.get("input_content", ""), images=images, videos=videos, audios=audios, files=files
+        )
+
+
 class TeamRunEvent(str, Enum):
     """Events that can be sent by the run() functions"""
 
@@ -25,6 +113,9 @@ class TeamRunEvent(str, Enum):
     run_error = "TeamRunError"
     run_cancelled = "TeamRunCancelled"
 
+    pre_hook_started = "TeamPreHookStarted"
+    pre_hook_completed = "TeamPreHookCompleted"
+
     tool_call_started = "TeamToolCallStarted"
     tool_call_completed = "TeamToolCallCompleted"
 
@@ -51,6 +142,7 @@ class BaseTeamRunEvent(BaseRunOutputEvent):
     team_id: str = ""
     team_name: str = ""
     run_id: Optional[str] = None
+    parent_run_id: Optional[str] = None
     session_id: Optional[str] = None
 
     workflow_id: Optional[str] = None
@@ -141,6 +233,11 @@ class RunErrorEvent(BaseTeamRunEvent):
     event: str = TeamRunEvent.run_error.value
     content: Optional[str] = None
 
+    # From exceptions
+    error_type: Optional[str] = None
+    error_id: Optional[str] = None
+    additional_data: Optional[Dict[str, Any]] = None
+
 
 @dataclass
 class RunCancelledEvent(BaseTeamRunEvent):
@@ -152,6 +249,20 @@ class RunCancelledEvent(BaseTeamRunEvent):
         return True
 
 
+@dataclass
+class PreHookStartedEvent(BaseTeamRunEvent):
+    event: str = TeamRunEvent.pre_hook_started.value
+    pre_hook_name: Optional[str] = None
+    run_input: Optional[TeamRunInput] = None
+
+
+@dataclass
+class PreHookCompletedEvent(BaseTeamRunEvent):
+    event: str = TeamRunEvent.pre_hook_completed.value
+    pre_hook_name: Optional[str] = None
+    run_input: Optional[TeamRunInput] = None
+
+
 @dataclass
 class MemoryUpdateStartedEvent(BaseTeamRunEvent):
     event: str = TeamRunEvent.memory_update_started.value
@@ -230,6 +341,8 @@ TeamRunOutputEvent = Union[
     RunCompletedEvent,
     RunErrorEvent,
     RunCancelledEvent,
+    PreHookStartedEvent,
+    PreHookCompletedEvent,
     ReasoningStartedEvent,
     ReasoningStepEvent,
     ReasoningCompletedEvent,
@@ -252,6 +365,8 @@ TEAM_RUN_EVENT_TYPE_REGISTRY = {
     TeamRunEvent.run_completed.value: RunCompletedEvent,
     TeamRunEvent.run_error.value: RunErrorEvent,
     TeamRunEvent.run_cancelled.value: RunCancelledEvent,
+    TeamRunEvent.pre_hook_started.value: PreHookStartedEvent,
+    TeamRunEvent.pre_hook_completed.value: PreHookCompletedEvent,
     TeamRunEvent.reasoning_started.value: ReasoningStartedEvent,
     TeamRunEvent.reasoning_step.value: ReasoningStepEvent,
     TeamRunEvent.reasoning_completed.value: ReasoningCompletedEvent,
@@ -278,78 +393,6 @@ def team_run_output_event_from_dict(data: dict) -> BaseTeamRunEvent:
     return event_class.from_dict(data)  # type: ignore
 
 
-@dataclass
-class TeamRunInput:
-    """Container for the raw input data passed to Agent.run().
-    This captures the original input exactly as provided by the user,
-    separate from the processed messages that go to the model.
-    Attributes:
-        input_content: The literal input message/content passed to run()
-        images: Images directly passed to run()
-        videos: Videos directly passed to run()
-        audios: Audio files directly passed to run()
-        files: Files directly passed to run()
-    """
-
-    input_content: Optional[Union[str, List, Dict, Message, BaseModel, List[Message]]] = 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]:
-        """Convert to dictionary representation"""
-        result: Dict[str, Any] = {}
-
-        if self.input_content is not None:
-            if isinstance(self.input_content, (str)):
-                result["input_content"] = self.input_content
-            elif isinstance(self.input_content, BaseModel):
-                result["input_content"] = self.input_content.model_dump(exclude_none=True)
-            elif isinstance(self.input_content, Message):
-                result["input_content"] = self.input_content.to_dict()
-            elif (
-                isinstance(self.input_content, list)
-                and self.input_content
-                and isinstance(self.input_content[0], Message)
-            ):
-                result["input_content"] = [m.to_dict() for m in self.input_content]
-            else:
-                result["input_content"] = self.input_content
-
-        if self.images:
-            result["images"] = [img.to_dict() for img in self.images]
-        if self.videos:
-            result["videos"] = [vid.to_dict() for vid in self.videos]
-        if self.audios:
-            result["audios"] = [aud.to_dict() for aud in self.audios]
-        if self.files:
-            result["files"] = [file.to_dict() for file in self.files]
-
-        return result
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "TeamRunInput":
-        """Create TeamRunInput from dictionary"""
-        images = None
-        if data.get("images"):
-            images = [Image.model_validate(img_data) for img_data in data["images"]]
-
-        videos = None
-        if data.get("videos"):
-            videos = [Video.model_validate(vid_data) for vid_data in data["videos"]]
-
-        audios = None
-        if data.get("audios"):
-            audios = [Audio.model_validate(aud_data) for aud_data in data["audios"]]
-
-        files = None
-        if data.get("files"):
-            files = [File.model_validate(file_data) for file_data in data["files"]]
-
-        return cls(input_content=data.get("input_content"), images=images, videos=videos, audios=audios, files=files)
-
-
 @dataclass
 class TeamRunOutput:
     """Response returned by Team.run() functions"""

agno/run/workflow.py

@@ -9,7 +9,6 @@ from agno.media import Audio, Image, Video
 from agno.run.agent import RunOutput
 from agno.run.base import BaseRunOutputEvent, RunStatus
 from agno.run.team import TeamRunOutput
-from agno.utils.log import log_error
 
 if TYPE_CHECKING:
     from agno.workflow.types import StepOutput, WorkflowMetrics
@@ -95,20 +94,6 @@ class BaseWorkflowRunOutputEvent(BaseRunOutputEvent):
 
         return _dict
 
-    def to_json(self, separators=(", ", ": "), indent: Optional[int] = 2) -> str:
-        import json
-
-        try:
-            _dict = self.to_dict()
-        except Exception:
-            log_error("Failed to convert response to json", exc_info=True)
-            raise
-
-        if indent is None:
-            return json.dumps(_dict, separators=separators)
-        else:
-            return json.dumps(_dict, indent=indent, separators=separators)
-
     @property
     def is_cancelled(self):
         return False
@@ -155,6 +140,11 @@ class WorkflowErrorEvent(BaseWorkflowRunOutputEvent):
     event: str = WorkflowRunEvent.workflow_error.value
     error: Optional[str] = None
 
+    # From exceptions
+    error_type: Optional[str] = None
+    error_id: Optional[str] = None
+    additional_data: Optional[Dict[str, Any]] = None
+
 
 @dataclass
 class WorkflowCancelledEvent(BaseWorkflowRunOutputEvent):