agno 2.0.0a1__py3-none-any.whl → 2.0.0rc1__py3-none-any.whl

agno/os/router.py

@@ -311,7 +311,7 @@ def get_base_router(
 
     # -- Main Routes ---
 
-    @router.get("/health", tags=["Core"])
+    @router.get("/health", tags=["Core"], operation_id="health_check")
     async def health_check():
         return JSONResponse(content={"status": "ok"})
 
@@ -320,6 +320,7 @@ def get_base_router(
         response_model=ConfigResponse,
         response_model_exclude_none=True,
         tags=["Core"],
+        operation_id="get_config",
     )
     async def config() -> ConfigResponse:
         return ConfigResponse(
@@ -347,6 +348,7 @@ def get_base_router(
         response_model=List[Model],
         response_model_exclude_none=True,
         tags=["Core"],
+        operation_id="get_models",
     )
     async def get_models():
         """Return the list of all models used by agents and teams in the contextual OS"""
@@ -368,7 +370,9 @@ def get_base_router(
 
     # -- Agent routes ---
 
-    @router.post("/agents/{agent_id}/runs", tags=["Agents"])
+    @router.post(
+        "/agents/{agent_id}/runs", tags=["Agents"], operation_id="create_agent_run", response_model_exclude_none=True
+    )
     async def create_agent_run(
         agent_id: str,
         message: str = Form(...),
@@ -475,6 +479,8 @@ def get_base_router(
     @router.post(
         "/agents/{agent_id}/runs/{run_id}/cancel",
         tags=["Agents"],
+        operation_id="cancel_agent_run",
+        response_model_exclude_none=True,
     )
     async def cancel_agent_run(
         agent_id: str,
@@ -492,6 +498,8 @@ def get_base_router(
     @router.post(
         "/agents/{agent_id}/runs/{run_id}/continue",
         tags=["Agents"],
+        operation_id="continue_agent_run",
+        response_model_exclude_none=True,
     )
     async def continue_agent_run(
         agent_id: str,
@@ -555,6 +563,7 @@ def get_base_router(
         response_model=List[AgentResponse],
         response_model_exclude_none=True,
         tags=["Agents"],
+        operation_id="get_agents",
     )
     async def get_agents():
         """Return the list of all Agents present in the contextual OS"""
@@ -572,6 +581,7 @@ def get_base_router(
         response_model=AgentResponse,
         response_model_exclude_none=True,
         tags=["Agents"],
+        operation_id="get_agent",
     )
     async def get_agent(agent_id: str):
         agent = get_agent_by_id(agent_id, os.agents)
@@ -582,7 +592,9 @@ def get_base_router(
 
     # -- Team routes ---
 
-    @router.post("/teams/{team_id}/runs", tags=["Teams"])
+    @router.post(
+        "/teams/{team_id}/runs", tags=["Teams"], operation_id="create_team_run", response_model_exclude_none=True
+    )
     async def create_team_run(
         team_id: str,
         message: str = Form(...),
@@ -686,6 +698,8 @@ def get_base_router(
     @router.post(
         "/teams/{team_id}/runs/{run_id}/cancel",
         tags=["Teams"],
+        operation_id="cancel_team_run",
+        response_model_exclude_none=True,
     )
     async def cancel_team_run(
         team_id: str,
@@ -705,6 +719,7 @@ def get_base_router(
         response_model=List[TeamResponse],
         response_model_exclude_none=True,
         tags=["Teams"],
+        operation_id="get_teams",
     )
     async def get_teams():
         """Return the list of all Teams present in the contextual OS"""
@@ -722,6 +737,7 @@ def get_base_router(
         response_model=TeamResponse,
         response_model_exclude_none=True,
         tags=["Teams"],
+        operation_id="get_team",
     )
     async def get_team(team_id: str):
         team = get_team_by_id(team_id, os.teams)
@@ -749,9 +765,10 @@ def get_base_router(
                 elif action == "start-workflow":
                     # Handle workflow execution directly via WebSocket
                     await handle_workflow_via_websocket(websocket, message, os)
-
         except Exception as e:
-            logger.error(f"WebSocket error: {e}")
+            if "1012" not in str(e):
+                logger.error(f"WebSocket error: {e}")
+        finally:
             # Clean up any run_ids associated with this websocket
             runs_to_remove = [run_id for run_id, ws in websocket_manager.active_connections.items() if ws == websocket]
             for run_id in runs_to_remove:
@@ -762,6 +779,7 @@ def get_base_router(
         response_model=List[WorkflowResponse],
         response_model_exclude_none=True,
         tags=["Workflows"],
+        operation_id="get_workflows",
     )
     async def get_workflows():
         if os.workflows is None:
@@ -774,6 +792,7 @@ def get_base_router(
         response_model=WorkflowResponse,
         response_model_exclude_none=True,
         tags=["Workflows"],
+        operation_id="get_workflow",
     )
     async def get_workflow(workflow_id: str):
         workflow = get_workflow_by_id(workflow_id, os.workflows)
@@ -782,7 +801,12 @@ def get_base_router(
 
         return WorkflowResponse.from_workflow(workflow)
 
-    @router.post("/workflows/{workflow_id}/runs", tags=["Workflows"])
+    @router.post(
+        "/workflows/{workflow_id}/runs",
+        tags=["Workflows"],
+        operation_id="create_workflow_run",
+        response_model_exclude_none=True,
+    )
     async def create_workflow_run(
         workflow_id: str,
         message: str = Form(...),
@@ -828,7 +852,9 @@ def get_base_router(
             # Handle unexpected runtime errors
             raise HTTPException(status_code=500, detail=f"Error running workflow: {str(e)}")
 
-    @router.post("/workflows/{workflow_id}/runs/{run_id}/cancel", tags=["Workflows"])
+    @router.post(
+        "/workflows/{workflow_id}/runs/{run_id}/cancel", tags=["Workflows"], operation_id="cancel_workflow_run"
+    )
     async def cancel_workflow_run(workflow_id: str, run_id: str):
         workflow = get_workflow_by_id(workflow_id, os.workflows)
 

agno/os/routers/evals/evals.py

@@ -37,7 +37,9 @@ def get_eval_router(
 def attach_routes(
     router: APIRouter, dbs: dict[str, BaseDb], agents: Optional[List[Agent]] = None, teams: Optional[List[Team]] = None
 ) -> APIRouter:
-    @router.get("/eval-runs", response_model=PaginatedResponse[EvalSchema], status_code=200)
+    @router.get(
+        "/eval-runs", response_model=PaginatedResponse[EvalSchema], status_code=200, operation_id="get_eval_runs"
+    )
     async def get_eval_runs(
         agent_id: Optional[str] = Query(default=None, description="Agent ID"),
         team_id: Optional[str] = Query(default=None, description="Team ID"),
@@ -76,7 +78,7 @@ def attach_routes(
             ),
         )
 
-    @router.get("/eval-runs/{eval_run_id}", response_model=EvalSchema, status_code=200)
+    @router.get("/eval-runs/{eval_run_id}", response_model=EvalSchema, status_code=200, operation_id="get_eval_run")
     async def get_eval_run(
         eval_run_id: str,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
@@ -88,7 +90,7 @@ def attach_routes(
 
         return EvalSchema.from_dict(eval_run)  # type: ignore
 
-    @router.delete("/eval-runs", status_code=204)
+    @router.delete("/eval-runs", status_code=204, operation_id="delete_eval_runs")
     async def delete_eval_runs(
         request: DeleteEvalRunsRequest,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
@@ -99,7 +101,9 @@ def attach_routes(
         except Exception as e:
             raise HTTPException(status_code=500, detail=f"Failed to delete eval runs: {e}")
 
-    @router.patch("/eval-runs/{eval_run_id}", response_model=EvalSchema, status_code=200)
+    @router.patch(
+        "/eval-runs/{eval_run_id}", response_model=EvalSchema, status_code=200, operation_id="update_eval_run"
+    )
     async def update_eval_run(
         eval_run_id: str,
         request: UpdateEvalRunRequest,
@@ -116,7 +120,7 @@ def attach_routes(
 
         return EvalSchema.from_dict(eval_run)  # type: ignore
 
-    @router.post("/eval-runs", response_model=EvalSchema, status_code=200)
+    @router.post("/eval-runs", response_model=EvalSchema, status_code=200, operation_id="run_eval")
     async def run_eval(
         eval_run_input: EvalRunInput,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),

agno/os/routers/knowledge/knowledge.py

@@ -37,7 +37,9 @@ def get_knowledge_router(
 
 
 def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> APIRouter:
-    @router.post("/knowledge/content", response_model=ContentResponseSchema, status_code=202)
+    @router.post(
+        "/knowledge/content", response_model=ContentResponseSchema, status_code=202, operation_id="upload_content"
+    )
     async def upload_content(
         background_tasks: BackgroundTasks,
         name: Optional[str] = Form(None),
@@ -126,7 +128,12 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         )
         return response
 
-    @router.patch("/knowledge/content/{content_id}", response_model=ContentResponseSchema, status_code=200)
+    @router.patch(
+        "/knowledge/content/{content_id}",
+        response_model=ContentResponseSchema,
+        status_code=200,
+        operation_id="update_content",
+    )
     async def update_content(
         content_id: str = Path(..., description="Content ID"),
         name: Optional[str] = Form(None, description="Content name"),
@@ -172,7 +179,12 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
 
         return ContentResponseSchema.from_dict(updated_content_dict)
 
-    @router.get("/knowledge/content", response_model=PaginatedResponse[ContentResponseSchema], status_code=200)
+    @router.get(
+        "/knowledge/content",
+        response_model=PaginatedResponse[ContentResponseSchema],
+        status_code=200,
+        operation_id="get_content",
+    )
     def get_content(
         limit: Optional[int] = Query(default=20, description="Number of content entries to return"),
         page: Optional[int] = Query(default=1, description="Page number"),
@@ -209,7 +221,12 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             ),
         )
 
-    @router.get("/knowledge/content/{content_id}", response_model=ContentResponseSchema, status_code=200)
+    @router.get(
+        "/knowledge/content/{content_id}",
+        response_model=ContentResponseSchema,
+        status_code=200,
+        operation_id="get_content_by_id",
+    )
     def get_content_by_id(
         content_id: str,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
@@ -241,6 +258,7 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         response_model=ContentResponseSchema,
         status_code=200,
         response_model_exclude_none=True,
+        operation_id="delete_content_by_id",
     )
     def delete_content_by_id(
         content_id: str,
@@ -254,7 +272,7 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             id=content_id,
         )
 
-    @router.delete("/knowledge/content", status_code=200)
+    @router.delete("/knowledge/content", status_code=200, operation_id="delete_all_content")
     def delete_all_content(
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
     ):
@@ -263,7 +281,12 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         knowledge.remove_all_content()
         return "success"
 
-    @router.get("/knowledge/content/{content_id}/status", status_code=200, response_model=ContentStatusResponse)
+    @router.get(
+        "/knowledge/content/{content_id}/status",
+        status_code=200,
+        response_model=ContentStatusResponse,
+        operation_id="get_content_status",
+    )
     def get_content_status(
         content_id: str,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
@@ -301,7 +324,7 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
 
         return ContentStatusResponse(status=status, status_message=status_message or "")
 
-    @router.get("/knowledge/config", status_code=200)
+    @router.get("/knowledge/config", status_code=200, operation_id="get_knowledge_config")
     def get_config(
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
     ) -> ConfigResponseSchema:

agno/os/routers/memory/memory.py

@@ -28,7 +28,7 @@ def get_memory_router(dbs: dict[str, BaseDb], settings: AgnoAPISettings = AgnoAP
 
 
 def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
-    @router.post("/memories", response_model=UserMemorySchema, status_code=200)
+    @router.post("/memories", response_model=UserMemorySchema, status_code=200, operation_id="create_memory")
     async def create_memory(
         payload: UserMemoryCreateSchema,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
@@ -48,14 +48,14 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
 
         return UserMemorySchema.from_dict(user_memory)  # type: ignore
 
-    @router.delete("/memories/{memory_id}", status_code=204)
+    @router.delete("/memories/{memory_id}", status_code=204, operation_id="delete_memory")
     async def delete_memory(
         memory_id: str = Path(), db_id: Optional[str] = Query(default=None, description="The ID of the database to use")
     ) -> None:
         db = get_db(dbs, db_id)
         db.delete_user_memory(memory_id=memory_id)
 
-    @router.delete("/memories", status_code=204)
+    @router.delete("/memories", status_code=204, operation_id="delete_memories")
     async def delete_memories(
         request: DeleteMemoriesRequest,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
@@ -63,7 +63,9 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
         db = get_db(dbs, db_id)
         db.delete_user_memories(memory_ids=request.memory_ids)
 
-    @router.get("/memories", response_model=PaginatedResponse[UserMemorySchema], status_code=200)
+    @router.get(
+        "/memories", response_model=PaginatedResponse[UserMemorySchema], status_code=200, operation_id="get_memories"
+    )
     async def get_memories(
         user_id: Optional[str] = Query(default=None, description="Filter memories by user ID"),
         agent_id: Optional[str] = Query(default=None, description="Filter memories by agent ID"),
@@ -99,7 +101,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
             ),
         )
 
-    @router.get("/memories/{memory_id}", response_model=UserMemorySchema, status_code=200)
+    @router.get("/memories/{memory_id}", response_model=UserMemorySchema, status_code=200, operation_id="get_memory")
     async def get_memory(
         memory_id: str = Path(),
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
@@ -111,14 +113,16 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
 
         return UserMemorySchema.from_dict(user_memory)  # type: ignore
 
-    @router.get("/memories/topics", response_model=List[str], status_code=200)
+    @router.get("/memories/topics", response_model=List[str], status_code=200, operation_id="get_memory_topics")
     async def get_topics(
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
     ) -> List[str]:
         db = get_db(dbs, db_id)
         return db.get_all_memory_topics()
 
-    @router.patch("/memories/{memory_id}", response_model=UserMemorySchema, status_code=200)
+    @router.patch(
+        "/memories/{memory_id}", response_model=UserMemorySchema, status_code=200, operation_id="update_memory"
+    )
     async def update_memory(
         payload: UserMemoryCreateSchema,
         memory_id: str = Path(),
@@ -139,7 +143,12 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
 
         return UserMemorySchema.from_dict(user_memory)  # type: ignore
 
-    @router.get("/user_memory_stats", response_model=PaginatedResponse[UserStatsSchema], status_code=200)
+    @router.get(
+        "/user_memory_stats",
+        response_model=PaginatedResponse[UserStatsSchema],
+        status_code=200,
+        operation_id="get_user_memory_stats",
+    )
     async def get_user_memory_stats(
         limit: Optional[int] = Query(default=20, description="Number of items to return"),
         page: Optional[int] = Query(default=1, description="Page number"),

agno/os/routers/metrics/metrics.py

@@ -20,7 +20,7 @@ def get_metrics_router(dbs: dict[str, BaseDb], settings: AgnoAPISettings = AgnoA
 
 
 def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
-    @router.get("/metrics", response_model=MetricsResponse, status_code=200)
+    @router.get("/metrics", response_model=MetricsResponse, status_code=200, operation_id="get_metrics")
     async def get_metrics(
         starting_date: Optional[date] = Query(default=None, description="Starting date to filter metrics (YYYY-MM-DD)"),
         ending_date: Optional[date] = Query(default=None, description="Ending date to filter metrics (YYYY-MM-DD)"),
@@ -40,7 +40,9 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
         except Exception as e:
             raise HTTPException(status_code=500, detail=f"Error getting metrics: {str(e)}")
 
-    @router.post("/metrics/refresh", response_model=List[DayAggregatedMetrics], status_code=200)
+    @router.post(
+        "/metrics/refresh", response_model=List[DayAggregatedMetrics], status_code=200, operation_id="refresh_metrics"
+    )
     async def calculate_metrics(
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
     ) -> List[DayAggregatedMetrics]:

agno/os/routers/session/session.py

@@ -30,7 +30,9 @@ def get_session_router(dbs: dict[str, BaseDb], settings: AgnoAPISettings = AgnoA
 
 
 def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
-    @router.get("/sessions", response_model=PaginatedResponse[SessionSchema], status_code=200)
+    @router.get(
+        "/sessions", response_model=PaginatedResponse[SessionSchema], status_code=200, operation_id="get_sessions"
+    )
     async def get_sessions(
         session_type: SessionType = Query(default=SessionType.AGENT, alias="type"),
         component_id: Optional[str] = Query(default=None, description="Filter sessions by component ID"),
@@ -69,6 +71,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
         "/sessions/{session_id}",
         response_model=Union[AgentSessionDetailSchema, TeamSessionDetailSchema, WorkflowSessionDetailSchema],
         status_code=200,
+        operation_id="get_session_by_id",
     )
     async def get_session_by_id(
         session_id: str = Path(...),
@@ -91,6 +94,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
         "/sessions/{session_id}/runs",
         response_model=Union[List[RunSchema], List[TeamRunSchema], List[WorkflowRunSchema]],
         status_code=200,
+        operation_id="get_session_runs",
     )
     async def get_session_runs(
         session_id: str = Path(..., description="Session ID", alias="session_id"),
@@ -118,7 +122,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
         else:
             return [RunSchema.from_dict(run) for run in runs]
 
-    @router.delete("/sessions/{session_id}", status_code=204)
+    @router.delete("/sessions/{session_id}", status_code=204, operation_id="delete_session")
     async def delete_session(
         session_id: str = Path(...),
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
@@ -126,7 +130,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
         db = get_db(dbs, db_id)
         db.delete_session(session_id=session_id)
 
-    @router.delete("/sessions", status_code=204)
+    @router.delete("/sessions", status_code=204, operation_id="delete_sessions")
     async def delete_sessions(
         request: DeleteSessionRequest,
         session_type: SessionType = Query(default=SessionType.AGENT, description="Session type filter", alias="type"),
@@ -141,6 +145,7 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
     @router.post(
         "/sessions/{session_id}/rename",
         response_model=Union[AgentSessionDetailSchema, TeamSessionDetailSchema, WorkflowSessionDetailSchema],
+        operation_id="rename_session",
     )
     async def rename_session(
         session_id: str = Path(...),

agno/os/settings.py

@@ -13,7 +13,6 @@ class AgnoAPISettings(BaseSettings):
     """
 
     env: str = "dev"
-    title: str = "Agno AgentOS"
 
     # Set to False to disable docs server at /docs and /redoc
     docs_enabled: bool = True

agno/run/agent.py

@@ -1,11 +1,11 @@
 from dataclasses import asdict, dataclass, field
 from enum import Enum
 from time import time
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Sequence, Union
 
 from pydantic import BaseModel
 
-from agno.media import AudioArtifact, AudioResponse, ImageArtifact, VideoArtifact
+from agno.media import AudioArtifact, AudioResponse, File, ImageArtifact, VideoArtifact
 from agno.models.message import Citations, Message
 from agno.models.metrics import Metrics
 from agno.models.response import ToolExecution
@@ -281,6 +281,78 @@ 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[ImageArtifact]] = None
+    videos: Optional[Sequence[VideoArtifact]] = None
+    audios: Optional[Sequence[AudioArtifact]] = 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]
+
+        return result
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "RunInput":
+        """Create RunInput from dictionary"""
+        images = None
+        if data.get("images"):
+            images = [ImageArtifact.model_validate(img_data) for img_data in data["images"]]
+
+        videos = None
+        if data.get("videos"):
+            videos = [VideoArtifact.model_validate(vid_data) for vid_data in data["videos"]]
+
+        audios = None
+        if data.get("audios"):
+            audios = [AudioArtifact.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"""
@@ -313,6 +385,9 @@ class RunOutput:
     audio: Optional[List[AudioArtifact]] = None  # Audio attached to the response
     response_audio: Optional[AudioResponse] = None  # Model audio response
 
+    # Input media and messages from user
+    input: Optional[RunInput] = None
+
     citations: Optional[Citations] = None
     references: Optional[List[MessageReferences]] = None
 
@@ -363,6 +438,7 @@ class RunOutput:
                 "videos",
                 "audio",
                 "response_audio",
+                "input",
                 "citations",
                 "events",
                 "additional_input",
@@ -446,6 +522,9 @@ class RunOutput:
                 else:
                     _dict["tools"].append(tool)
 
+        if self.input is not None:
+            _dict["input"] = self.input.to_dict()
+
         return _dict
 
     def to_json(self) -> str:
@@ -488,6 +567,11 @@ class RunOutput:
         response_audio = data.pop("response_audio", None)
         response_audio = AudioResponse.model_validate(response_audio) if response_audio else None
 
+        input_data = data.pop("input", None)
+        input_obj = None
+        if input_data:
+            input_obj = RunInput.from_dict(input_data)
+
         metrics = data.pop("metrics", None)
         if metrics:
             metrics = Metrics(**metrics)
@@ -518,6 +602,7 @@ class RunOutput:
             audio=audio,
             videos=videos,
             response_audio=response_audio,
+            input=input_obj,
             events=events,
             additional_input=additional_input,
             reasoning_steps=reasoning_steps,

agno/run/cancel.py

@@ -18,7 +18,6 @@ class RunCancellationManager:
         """Register a new run as not cancelled."""
         with self._lock:
             self._cancelled_runs[run_id] = False
-            logger.debug(f"Registered run {run_id} for cancellation tracking")
 
     def cancel_run(self, run_id: str) -> bool:
         """Cancel a run by marking it as cancelled.
@@ -45,7 +44,6 @@ class RunCancellationManager:
         with self._lock:
             if run_id in self._cancelled_runs:
                 del self._cancelled_runs[run_id]
-                logger.debug(f"Cleaned up cancellation tracking for run {run_id}")
 
     def raise_if_cancelled(self, run_id: str) -> None:
         """Check if a run should be cancelled and raise exception if so."""

agno/team/team.py

@@ -25,7 +25,7 @@ from typing import (
     get_args,
     overload,
 )
-from uuid import NAMESPACE_DNS, uuid4, uuid5
+from uuid import uuid4
 
 from pydantic import BaseModel
 
@@ -563,7 +563,7 @@ class Team:
         """
         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())