agno 2.0.3__py3-none-any.whl → 2.0.5__py3-none-any.whl

agno/os/routers/evals/utils.py

@@ -35,7 +35,7 @@ async def run_accuracy_eval(
         name=eval_run_input.name,
     )
 
-    result = accuracy_eval.run(print_results=False, print_summary=False)
+    result = await accuracy_eval.arun(print_results=False, print_summary=False)
     if not result:
         raise HTTPException(status_code=500, detail="Failed to run accuracy evaluation")
 
@@ -60,16 +60,16 @@ async def run_performance_eval(
     """Run a performance evaluation for the given agent or team"""
     if agent:
 
-        def run_component():  # type: ignore
-            return agent.run(eval_run_input.input)
+        async def run_component():  # type: ignore
+            return await agent.arun(eval_run_input.input)
 
         model_id = agent.model.id if agent and agent.model else None
         model_provider = agent.model.provider if agent and agent.model else None
 
     elif team:
 
-        def run_component():
-            return team.run(eval_run_input.input)
+        async def run_component():
+            return await team.arun(eval_run_input.input)
 
         model_id = team.model.id if team and team.model else None
         model_provider = team.model.provider if team and team.model else None
@@ -85,7 +85,7 @@ async def run_performance_eval(
         model_id=model_id,
         model_provider=model_provider,
     )
-    result = performance_eval.run(print_results=False, print_summary=False)
+    result = await performance_eval.arun(print_results=False, print_summary=False)
     if not result:
         raise HTTPException(status_code=500, detail="Failed to run performance evaluation")
 
@@ -119,7 +119,7 @@ async def run_reliability_eval(
         raise HTTPException(status_code=400, detail="expected_tool_calls is required for reliability evaluations")
 
     if agent:
-        agent_response = agent.run(eval_run_input.input)
+        agent_response = await agent.arun(eval_run_input.input)
         reliability_eval = ReliabilityEval(
             db=db,
             name=eval_run_input.name,
@@ -130,7 +130,7 @@ async def run_reliability_eval(
         model_provider = agent.model.provider if agent and agent.model else None
 
     elif team:
-        team_response = team.run(eval_run_input.input)
+        team_response = await team.arun(eval_run_input.input)
         reliability_eval = ReliabilityEval(
             db=db,
             name=eval_run_input.name,
@@ -140,7 +140,7 @@ async def run_reliability_eval(
         model_id = team.model.id if team and team.model else None
         model_provider = team.model.provider if team and team.model else None
 
-    result = reliability_eval.run(print_results=False)
+    result = await reliability_eval.arun(print_results=False)
     if not result:
         raise HTTPException(status_code=500, detail="Failed to run reliability evaluation")
 

agno/os/routers/health.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+
+from agno.os.schema import HealthResponse
+
+
+def get_health_router() -> APIRouter:
+    router = APIRouter(tags=["Health"])
+
+    @router.get(
+        "/health",
+        operation_id="health_check",
+        summary="Health Check",
+        description="Check the health status of the AgentOS API. Returns a simple status indicator.",
+        response_model=HealthResponse,
+        responses={
+            200: {
+                "description": "API is healthy and operational",
+                "content": {"application/json": {"example": {"status": "ok"}}},
+            }
+        },
+    )
+    async def health_check() -> HealthResponse:
+        return HealthResponse(status="ok")
+
+    return router

agno/os/routers/home.py

@@ -0,0 +1,52 @@
+from typing import TYPE_CHECKING
+
+from fastapi import APIRouter
+
+if TYPE_CHECKING:
+    from agno.os.app import AgentOS
+
+
+def get_home_router(os: "AgentOS") -> APIRouter:
+    router = APIRouter(tags=["Home"])
+
+    @router.get(
+        "/",
+        operation_id="get_api_info",
+        summary="API Information",
+        description=(
+            "Get basic information about this AgentOS API instance, including:\n\n"
+            "- API metadata and version\n"
+            "- Available capabilities overview\n"
+            "- Links to key endpoints and documentation"
+        ),
+        responses={
+            200: {
+                "description": "API information retrieved successfully",
+                "content": {
+                    "application/json": {
+                        "examples": {
+                            "home": {
+                                "summary": "Example home response",
+                                "value": {
+                                    "name": "AgentOS API",
+                                    "description": "AI Agent Operating System API",
+                                    "os_id": "demo-os",
+                                    "version": "1.0.0",
+                                },
+                            }
+                        }
+                    }
+                },
+            }
+        },
+    )
+    async def get_api_info():
+        """Get basic API information and available capabilities"""
+        return {
+            "name": "AgentOS API",
+            "description": os.description or "AI Agent Operating System API",
+            "os_id": os.os_id or "agno-agentos",
+            "version": os.version or "1.0.0",
+        }
+
+    return router

agno/os/routers/knowledge/knowledge.py

@@ -2,7 +2,6 @@ import json
 import logging
 import math
 from typing import Dict, List, Optional
-from uuid import uuid4
 
 from fastapi import APIRouter, BackgroundTasks, Depends, File, Form, HTTPException, Path, Query, UploadFile
 
@@ -34,6 +33,7 @@ from agno.os.schema import (
 from agno.os.settings import AgnoAPISettings
 from agno.os.utils import get_knowledge_instance_by_db_id
 from agno.utils.log import log_debug, log_info
+from agno.utils.string import generate_id
 
 logger = logging.getLogger(__name__)
 
@@ -102,8 +102,7 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         db_id: Optional[str] = Query(default=None, description="Database ID to use for content storage"),
     ):
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
-        content_id = str(uuid4())
-        log_info(f"Adding content: {name}, {description}, {url}, {metadata} with ID: {content_id}")
+        log_info(f"Adding content: {name}, {description}, {url}, {metadata}")
 
         parsed_metadata = None
         if metadata:
@@ -166,10 +165,14 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             file_data=file_data,
             size=file.size if file else None if text_content else None,
         )
-        background_tasks.add_task(process_content, knowledge, content_id, content, reader_id, chunker)
+        content_hash = knowledge._build_content_hash(content)
+        content.content_hash = content_hash
+        content.id = generate_id(content_hash)
+
+        background_tasks.add_task(process_content, knowledge, content, reader_id, chunker)
 
         response = ContentResponseSchema(
-            id=content_id,
+            id=content.id,
             name=name,
             description=description,
             metadata=parsed_metadata,
@@ -802,15 +805,13 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
 
 async def process_content(
     knowledge: Knowledge,
-    content_id: str,
     content: Content,
     reader_id: Optional[str] = None,
     chunker: Optional[str] = None,
 ):
     """Background task to process the content"""
-    log_info(f"Processing content {content_id}")
+
     try:
-        content.id = content_id
         if reader_id:
             reader = None
             if knowledge.readers and reader_id in knowledge.readers:
@@ -834,16 +835,15 @@ async def process_content(
 
         log_debug(f"Using reader: {content.reader.__class__.__name__}")
         await knowledge._load_content(content, upsert=False, skip_if_exists=True)
-        log_info(f"Content {content_id} processed successfully")
+        log_info(f"Content {content.id} processed successfully")
     except Exception as e:
-        log_info(f"Error processing content {content_id}: {e}")
+        log_info(f"Error processing content: {e}")
         # Mark content as failed in the contents DB
         try:
             from agno.knowledge.content import ContentStatus as KnowledgeContentStatus
 
             content.status = KnowledgeContentStatus.FAILED
             content.status_message = str(e)
-            content.id = content_id
             knowledge.patch_content(content)
         except Exception:
             # Swallow any secondary errors to avoid crashing the background task

agno/os/routers/session/session.py

@@ -222,7 +222,9 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
         db = get_db(dbs, db_id)
         session = db.get_session(session_id=session_id, session_type=session_type)
         if not session:
-            raise HTTPException(status_code=404, detail=f"Session with id '{session_id}' not found")
+            raise HTTPException(
+                status_code=404, detail=f"{session_type.value.title()} Session with id '{session_id}' not found"
+            )
 
         if session_type == SessionType.AGENT:
             return AgentSessionDetailSchema.from_session(session)  # type: ignore
@@ -233,7 +235,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
 
     @router.get(
         "/sessions/{session_id}/runs",
-        response_model=Union[List[RunSchema], List[TeamRunSchema], List[WorkflowRunSchema]],
+        response_model=List[Union[RunSchema, TeamRunSchema, WorkflowRunSchema]],
         status_code=200,
         operation_id="get_session_runs",
         summary="Get Session Runs",
@@ -251,7 +253,8 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
                                 "summary": "Example completed run",
                                 "value": {
                                     "run_id": "fcdf50f0-7c32-4593-b2ef-68a558774340",
-                                    "agent_session_id": "80056af0-c7a5-4d69-b6a2-c3eba9f040e0",
+                                    "parent_run_id": "80056af0-c7a5-4d69-b6a2-c3eba9f040e0",
+                                    "agent_id": "basic-agent",
                                     "user_id": "",
                                     "run_input": "Which tools do you have access to?",
                                     "content": "I don't have access to external tools or the internet. However, I can assist you with a wide range of topics by providing information, answering questions, and offering suggestions based on the knowledge I've been trained on. If there's anything specific you need help with, feel free to ask!",
@@ -351,7 +354,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
             default=SessionType.AGENT, description="Session type (agent, team, or workflow)", alias="type"
         ),
         db_id: Optional[str] = Query(default=None, description="Database ID to query runs from"),
-    ) -> Union[List[RunSchema], List[TeamRunSchema], List[WorkflowRunSchema]]:
+    ) -> List[Union[RunSchema, TeamRunSchema, WorkflowRunSchema]]:
         db = get_db(dbs, db_id)
         session = db.get_session(session_id=session_id, session_type=session_type, deserialize=False)
         if not session:
@@ -365,13 +368,26 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
             return [RunSchema.from_dict(run) for run in runs]
 
         elif session_type == SessionType.TEAM:
-            return [TeamRunSchema.from_dict(run) for run in runs]
+            run_responses: List[Union[RunSchema, TeamRunSchema, WorkflowRunSchema]] = []
+            for run in runs:
+                if run.get("agent_id") is not None:
+                    run_responses.append(RunSchema.from_dict(run))
+                elif run.get("team_id") is not None:
+                    run_responses.append(TeamRunSchema.from_dict(run))
+            return run_responses
 
         elif session_type == SessionType.WORKFLOW:
-            return [WorkflowRunSchema.from_dict(run) for run in runs]
-
+            run_responses: List[Union[RunSchema, TeamRunSchema, WorkflowRunSchema]] = []  # type: ignore
+            for run in runs:
+                if run.get("workflow_id") is not None:
+                    run_responses.append(WorkflowRunSchema.from_dict(run))
+                elif run.get("team_id") is not None:
+                    run_responses.append(TeamRunSchema.from_dict(run))
+                else:
+                    run_responses.append(RunSchema.from_dict(run))
+            return run_responses
         else:
-            return [RunSchema.from_dict(run) for run in runs]
+            raise HTTPException(status_code=400, detail=f"Invalid session type: {session_type}")
 
     @router.delete(
         "/sessions/{session_id}",

agno/os/schema.py

@@ -765,6 +765,7 @@ class TeamSessionDetailSchema(BaseModel):
     team_data: Optional[dict]
     created_at: Optional[datetime]
     updated_at: Optional[datetime]
+    total_tokens: Optional[int]
 
     @classmethod
     def from_session(cls, session: TeamSession) -> "TeamSessionDetailSchema":
@@ -826,17 +827,21 @@ class WorkflowSessionDetailSchema(BaseModel):
 
 class RunSchema(BaseModel):
     run_id: str
-    agent_session_id: Optional[str]
+    parent_run_id: Optional[str]
+    agent_id: Optional[str]
     user_id: Optional[str]
     run_input: Optional[str]
     content: Optional[Union[str, dict]]
     run_response_format: Optional[str]
     reasoning_content: Optional[str]
+    reasoning_steps: Optional[List[dict]]
     metrics: Optional[dict]
     messages: Optional[List[dict]]
     tools: Optional[List[dict]]
     events: Optional[List[dict]]
     created_at: Optional[datetime]
+    references: Optional[List[dict]]
+    reasoning_messages: Optional[List[dict]]
 
     @classmethod
     def from_dict(cls, run_dict: Dict[str, Any]) -> "RunSchema":
@@ -844,16 +849,20 @@ class RunSchema(BaseModel):
         run_response_format = "text" if run_dict.get("content_type", "str") == "str" else "json"
         return cls(
             run_id=run_dict.get("run_id", ""),
-            agent_session_id=run_dict.get("session_id", ""),
+            parent_run_id=run_dict.get("parent_run_id", ""),
+            agent_id=run_dict.get("agent_id", ""),
             user_id=run_dict.get("user_id", ""),
             run_input=run_input,
             content=run_dict.get("content", ""),
             run_response_format=run_response_format,
             reasoning_content=run_dict.get("reasoning_content", ""),
+            reasoning_steps=run_dict.get("reasoning_steps", []),
             metrics=run_dict.get("metrics", {}),
             messages=[message for message in run_dict.get("messages", [])] if run_dict.get("messages") else None,
             tools=[tool for tool in run_dict.get("tools", [])] if run_dict.get("tools") else None,
             events=[event for event in run_dict["events"]] if run_dict.get("events") else None,
+            references=run_dict.get("references", []),
+            reasoning_messages=run_dict.get("reasoning_messages", []),
             created_at=datetime.fromtimestamp(run_dict.get("created_at", 0), tz=timezone.utc)
             if run_dict.get("created_at") is not None
             else None,
@@ -863,8 +872,10 @@ class RunSchema(BaseModel):
 class TeamRunSchema(BaseModel):
     run_id: str
     parent_run_id: Optional[str]
+    team_id: Optional[str]
     content: Optional[Union[str, dict]]
     reasoning_content: Optional[str]
+    reasoning_steps: Optional[List[dict]]
     run_input: Optional[str]
     run_response_format: Optional[str]
     metrics: Optional[dict]
@@ -872,6 +883,8 @@ class TeamRunSchema(BaseModel):
     messages: Optional[List[dict]]
     events: Optional[List[dict]]
     created_at: Optional[datetime]
+    references: Optional[List[dict]]
+    reasoning_messages: Optional[List[dict]]
 
     @classmethod
     def from_dict(cls, run_dict: Dict[str, Any]) -> "TeamRunSchema":
@@ -880,10 +893,12 @@ class TeamRunSchema(BaseModel):
         return cls(
             run_id=run_dict.get("run_id", ""),
             parent_run_id=run_dict.get("parent_run_id", ""),
+            team_id=run_dict.get("team_id", ""),
             run_input=run_input,
             content=run_dict.get("content", ""),
             run_response_format=run_response_format,
             reasoning_content=run_dict.get("reasoning_content", ""),
+            reasoning_steps=run_dict.get("reasoning_steps", []),
             metrics=run_dict.get("metrics", {}),
             messages=[message for message in run_dict.get("messages", [])] if run_dict.get("messages") else None,
             tools=[tool for tool in run_dict.get("tools", [])] if run_dict.get("tools") else None,
@@ -891,12 +906,15 @@ class TeamRunSchema(BaseModel):
             created_at=datetime.fromtimestamp(run_dict.get("created_at", 0), tz=timezone.utc)
             if run_dict.get("created_at") is not None
             else None,
+            references=run_dict.get("references", []),
+            reasoning_messages=run_dict.get("reasoning_messages", []),
         )
 
 
 class WorkflowRunSchema(BaseModel):
     run_id: str
     run_input: Optional[str]
+    workflow_id: Optional[str]
     user_id: Optional[str]
     content: Optional[Union[str, dict]]
     content_type: Optional[str]
@@ -905,6 +923,10 @@ class WorkflowRunSchema(BaseModel):
     step_executor_runs: Optional[list[dict]]
     metrics: Optional[dict]
     created_at: Optional[int]
+    reasoning_content: Optional[str]
+    reasoning_steps: Optional[List[dict]]
+    references: Optional[List[dict]]
+    reasoning_messages: Optional[List[dict]]
 
     @classmethod
     def from_dict(cls, run_response: Dict[str, Any]) -> "WorkflowRunSchema":
@@ -912,6 +934,7 @@ class WorkflowRunSchema(BaseModel):
         return cls(
             run_id=run_response.get("run_id", ""),
             run_input=run_input,
+            workflow_id=run_response.get("workflow_id", ""),
             user_id=run_response.get("user_id", ""),
             content=run_response.get("content", ""),
             content_type=run_response.get("content_type", ""),
@@ -920,6 +943,10 @@ class WorkflowRunSchema(BaseModel):
             step_results=run_response.get("step_results", []),
             step_executor_runs=run_response.get("step_executor_runs", []),
             created_at=run_response["created_at"],
+            reasoning_content=run_response.get("reasoning_content", ""),
+            reasoning_steps=run_response.get("reasoning_steps", []),
+            references=run_response.get("references", []),
+            reasoning_messages=run_response.get("reasoning_messages", []),
         )
 
 

agno/os/utils.py

@@ -1,5 +1,4 @@
 from typing import Any, Callable, Dict, List, Optional, Union
-from uuid import uuid4
 
 from fastapi import HTTPException, UploadFile
 
@@ -261,10 +260,3 @@ def _generate_schema_from_params(params: Dict[str, Any]) -> Dict[str, Any]:
         schema["required"] = required
 
     return schema
-
-
-def generate_id(name: Optional[str] = None) -> str:
-    if name:
-        return name.lower().replace(" ", "-").replace("_", "-")
-    else:
-        return str(uuid4())

agno/run/agent.py

@@ -559,7 +559,7 @@ class RunOutput:
         events = [run_output_event_from_dict(event) for event in events] if events else None
 
         messages = data.pop("messages", None)
-        messages = [Message.model_validate(message) for message in messages] if messages else None
+        messages = [Message.from_dict(message) for message in messages] if messages else None
 
         citations = data.pop("citations", None)
         citations = Citations.model_validate(citations) if citations else None
@@ -591,7 +591,7 @@ class RunOutput:
         additional_input = data.pop("additional_input", None)
 
         if additional_input is not None:
-            additional_input = [Message.model_validate(message) for message in additional_input]
+            additional_input = [Message.from_dict(message) for message in additional_input]
 
         reasoning_steps = data.pop("reasoning_steps", None)
         if reasoning_steps is not None:
@@ -599,7 +599,7 @@ class RunOutput:
 
         reasoning_messages = data.pop("reasoning_messages", None)
         if reasoning_messages is not None:
-            reasoning_messages = [Message.model_validate(message) for message in reasoning_messages]
+            reasoning_messages = [Message.from_dict(message) for message in reasoning_messages]
 
         references = data.pop("references", None)
         if references is not None:

agno/run/team.py

@@ -519,7 +519,7 @@ class TeamRunOutput:
         events = final_events
 
         messages = data.pop("messages", None)
-        messages = [Message.model_validate(message) for message in messages] if messages else None
+        messages = [Message.from_dict(message) for message in messages] if messages else None
 
         member_responses = data.pop("member_responses", [])
         parsed_member_responses: List[Union["TeamRunOutput", RunOutput]] = []
@@ -532,7 +532,7 @@ class TeamRunOutput:
 
         additional_input = data.pop("additional_input", None)
         if additional_input is not None:
-            additional_input = [Message.model_validate(message) for message in additional_input]
+            additional_input = [Message.from_dict(message) for message in additional_input]
 
         reasoning_steps = data.pop("reasoning_steps", None)
         if reasoning_steps is not None:
@@ -540,7 +540,7 @@ class TeamRunOutput:
 
         reasoning_messages = data.pop("reasoning_messages", None)
         if reasoning_messages is not None:
-            reasoning_messages = [Message.model_validate(message) for message in reasoning_messages]
+            reasoning_messages = [Message.from_dict(message) for message in reasoning_messages]
 
         references = data.pop("references", None)
         if references is not None:

agno/run/workflow.py

@@ -7,7 +7,7 @@ from pydantic import BaseModel
 
 from agno.media import Audio, Image, Video
 from agno.run.agent import RunOutput
-from agno.run.base import RunStatus
+from agno.run.base import BaseRunOutputEvent, RunStatus
 from agno.run.team import TeamRunOutput
 from agno.utils.log import log_error
 
@@ -53,7 +53,7 @@ class WorkflowRunEvent(str, Enum):
 
 
 @dataclass
-class BaseWorkflowRunOutputEvent:
+class BaseWorkflowRunOutputEvent(BaseRunOutputEvent):
     """Base class for all workflow run response events"""
 
     created_at: int = field(default_factory=lambda: int(time()))
@@ -75,19 +75,23 @@ class BaseWorkflowRunOutputEvent:
 
         # Handle StepOutput fields that contain Message objects
         if hasattr(self, "step_results") and self.step_results is not None:
-            _dict["step_results"] = [step.to_dict() for step in self.step_results]
+            _dict["step_results"] = [step.to_dict() if hasattr(step, "to_dict") else step for step in self.step_results]
 
         if hasattr(self, "step_response") and self.step_response is not None:
-            _dict["step_response"] = self.step_response.to_dict()
+            _dict["step_response"] = (
+                self.step_response.to_dict() if hasattr(self.step_response, "to_dict") else self.step_response
+            )
 
         if hasattr(self, "iteration_results") and self.iteration_results is not None:
-            _dict["iteration_results"] = [step.to_dict() for step in self.iteration_results]
+            _dict["iteration_results"] = [
+                step.to_dict() if hasattr(step, "to_dict") else step for step in self.iteration_results
+            ]
 
         if hasattr(self, "all_results") and self.all_results is not None:
-            _dict["all_results"] = [[step.to_dict() for step in iteration] for iteration in self.all_results]
-
-        if hasattr(self, "step_results") and self.step_results is not None:
-            _dict["step_results"] = [step.to_dict() for step in self.step_results]
+            _dict["all_results"] = [
+                [step.to_dict() if hasattr(step, "to_dict") else step for step in iteration]
+                for iteration in self.all_results
+            ]
 
         return _dict
 
@@ -420,6 +424,39 @@ WorkflowRunOutputEvent = Union[
     CustomEvent,
 ]
 
+# Map event string to dataclass for workflow events
+WORKFLOW_RUN_EVENT_TYPE_REGISTRY = {
+    WorkflowRunEvent.workflow_started.value: WorkflowStartedEvent,
+    WorkflowRunEvent.workflow_completed.value: WorkflowCompletedEvent,
+    WorkflowRunEvent.workflow_cancelled.value: WorkflowCancelledEvent,
+    WorkflowRunEvent.workflow_error.value: WorkflowErrorEvent,
+    WorkflowRunEvent.step_started.value: StepStartedEvent,
+    WorkflowRunEvent.step_completed.value: StepCompletedEvent,
+    WorkflowRunEvent.step_error.value: StepErrorEvent,
+    WorkflowRunEvent.loop_execution_started.value: LoopExecutionStartedEvent,
+    WorkflowRunEvent.loop_iteration_started.value: LoopIterationStartedEvent,
+    WorkflowRunEvent.loop_iteration_completed.value: LoopIterationCompletedEvent,
+    WorkflowRunEvent.loop_execution_completed.value: LoopExecutionCompletedEvent,
+    WorkflowRunEvent.parallel_execution_started.value: ParallelExecutionStartedEvent,
+    WorkflowRunEvent.parallel_execution_completed.value: ParallelExecutionCompletedEvent,
+    WorkflowRunEvent.condition_execution_started.value: ConditionExecutionStartedEvent,
+    WorkflowRunEvent.condition_execution_completed.value: ConditionExecutionCompletedEvent,
+    WorkflowRunEvent.router_execution_started.value: RouterExecutionStartedEvent,
+    WorkflowRunEvent.router_execution_completed.value: RouterExecutionCompletedEvent,
+    WorkflowRunEvent.steps_execution_started.value: StepsExecutionStartedEvent,
+    WorkflowRunEvent.steps_execution_completed.value: StepsExecutionCompletedEvent,
+    WorkflowRunEvent.step_output.value: StepOutputEvent,
+    WorkflowRunEvent.custom_event.value: CustomEvent,
+}
+
+
+def workflow_run_output_event_from_dict(data: dict) -> BaseWorkflowRunOutputEvent:
+    event_type = data.get("event", "")
+    cls = WORKFLOW_RUN_EVENT_TYPE_REGISTRY.get(event_type)
+    if not cls:
+        raise ValueError(f"Unknown workflow event type: {event_type}")
+    return cls.from_dict(data)  # type: ignore
+
 
 @dataclass
 class WorkflowRunOutput:
@@ -568,7 +605,24 @@ class WorkflowRunOutput:
         response_audio = data.pop("response_audio", None)
         response_audio = Audio.model_validate(response_audio) if response_audio else None
 
-        events = data.pop("events", [])
+        events_data = data.pop("events", [])
+        final_events = []
+        for event in events_data or []:
+            if "agent_id" in event:
+                # Agent event from agent step
+                from agno.run.agent import run_output_event_from_dict
+
+                event = run_output_event_from_dict(event)
+            elif "team_id" in event:
+                # Team event from team step
+                from agno.run.team import team_run_output_event_from_dict
+
+                event = team_run_output_event_from_dict(event)
+            else:
+                # Pure workflow event
+                event = workflow_run_output_event_from_dict(event)
+            final_events.append(event)
+        events = final_events
 
         return cls(
             step_results=parsed_step_results,

agno/session/team.py

@@ -92,6 +92,7 @@ class TeamSession:
         if messages is None:
             return
 
+        # Make message duration None
         for m in messages or []:
             if m.metrics is not None:
                 m.metrics.duration = None