agno 2.3.19__py3-none-any.whl → 2.3.21__py3-none-any.whl

agno/os/routers/evals/utils.py

@@ -68,15 +68,11 @@ async def run_agent_as_judge_eval(
     if agent:
         agent_response = await agent.arun(eval_run_input.input, stream=False)
         output = str(agent_response.content) if agent_response.content else ""
-        model_id = agent.model.id if agent and agent.model else None
-        model_provider = agent.model.provider if agent and agent.model else None
         agent_id = agent.id
         team_id = None
     elif team:
         team_response = await team.arun(eval_run_input.input, stream=False)
         output = str(team_response.content) if team_response.content else ""
-        model_id = team.model.id if team and team.model else None
-        model_provider = team.model.provider if team and team.model else None
         agent_id = None
         team_id = team.id
     else:
@@ -98,13 +94,17 @@ async def run_agent_as_judge_eval(
     if not result:
         raise HTTPException(status_code=500, detail="Failed to run agent as judge evaluation")
 
+    # Use evaluator's model
+    eval_model_id = agent_as_judge_eval.model.id if agent_as_judge_eval.model is not None else None
+    eval_model_provider = agent_as_judge_eval.model.provider if agent_as_judge_eval.model is not None else None
+
     eval_run = EvalSchema.from_agent_as_judge_eval(
         agent_as_judge_eval=agent_as_judge_eval,
         result=result,
         agent_id=agent_id,
         team_id=team_id,
-        model_id=model_id,
-        model_provider=model_provider,
+        model_id=eval_model_id,
+        model_provider=eval_model_provider,
     )
 
     # Restore original model after eval

agno/os/routers/knowledge/schemas.py

@@ -82,7 +82,7 @@ class ContentResponseSchema(BaseModel):
             status=status,
             status_message=content.get("status_message"),
             created_at=parse_timestamp(content.get("created_at")),
-            updated_at=parse_timestamp(content.get("updated_at")),
+            updated_at=parse_timestamp(content.get("updated_at", content.get("created_at", 0))),
             # TODO: These fields are not available in the Content class. Fix the inconsistency
             access_count=None,
             linked_to=None,

agno/os/routers/memory/schemas.py

@@ -1,3 +1,4 @@
+import json
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
@@ -25,12 +26,24 @@ class UserMemorySchema(BaseModel):
         if memory_dict["memory"] == "":
             return None
 
+        # Handle nested memory content (relevant for some memories migrated from v1)
+        if isinstance(memory_dict["memory"], dict):
+            if memory_dict["memory"].get("memory") is not None:
+                memory = str(memory_dict["memory"]["memory"])
+            else:
+                try:
+                    memory = json.dumps(memory_dict["memory"])
+                except json.JSONDecodeError:
+                    memory = str(memory_dict["memory"])
+        else:
+            memory = memory_dict["memory"]
+
         return cls(
             memory_id=memory_dict["memory_id"],
             user_id=str(memory_dict["user_id"]),
             agent_id=memory_dict.get("agent_id"),
             team_id=memory_dict.get("team_id"),
-            memory=memory_dict["memory"],
+            memory=memory,
             topics=memory_dict.get("topics", []),
             updated_at=memory_dict["updated_at"],
         )

agno/os/routers/metrics/schemas.py

@@ -35,7 +35,7 @@ class DayAggregatedMetrics(BaseModel):
             team_runs_count=metrics_dict.get("team_runs_count", 0),
             team_sessions_count=metrics_dict.get("team_sessions_count", 0),
             token_metrics=metrics_dict.get("token_metrics", {}),
-            updated_at=metrics_dict.get("updated_at", 0),
+            updated_at=metrics_dict.get("updated_at", metrics_dict.get("created_at", 0)),
             users_count=metrics_dict.get("users_count", 0),
             workflow_runs_count=metrics_dict.get("workflow_runs_count", 0),
             workflow_sessions_count=metrics_dict.get("workflow_sessions_count", 0),

agno/os/schema.py

@@ -193,7 +193,7 @@ class SessionSchema(BaseModel):
         session_data = session.get("session_data", {}) or {}
 
         created_at = session.get("created_at", 0)
-        updated_at = session.get("updated_at", 0)
+        updated_at = session.get("updated_at", created_at)
 
         # Handle created_at and updated_at as either ISO 8601 string or timestamp
         def parse_datetime(val):
@@ -213,7 +213,7 @@ class SessionSchema(BaseModel):
             return None
 
         created_at = parse_datetime(session.get("created_at", 0))
-        updated_at = parse_datetime(session.get("updated_at", 0))
+        updated_at = parse_datetime(session.get("updated_at", created_at))
         return cls(
             session_id=session.get("session_id", ""),
             session_name=session_name,
@@ -265,6 +265,8 @@ class AgentSessionDetailSchema(BaseModel):
     @classmethod
     def from_session(cls, session: AgentSession) -> "AgentSessionDetailSchema":
         session_name = get_session_name({**session.to_dict(), "session_type": "agent"})
+        created_at = datetime.fromtimestamp(session.created_at, tz=timezone.utc) if session.created_at else None
+        updated_at = datetime.fromtimestamp(session.updated_at, tz=timezone.utc) if session.updated_at else created_at
         return cls(
             user_id=session.user_id,
             agent_session_id=session.session_id,
@@ -280,8 +282,8 @@ class AgentSessionDetailSchema(BaseModel):
             metrics=session.session_data.get("session_metrics", {}) if session.session_data else None,  # type: ignore
             metadata=session.metadata,
             chat_history=[message.to_dict() for message in session.get_chat_history()],
-            created_at=datetime.fromtimestamp(session.created_at, tz=timezone.utc) if session.created_at else None,
-            updated_at=datetime.fromtimestamp(session.updated_at, tz=timezone.utc) if session.updated_at else None,
+            created_at=created_at,
+            updated_at=updated_at,
         )
 
 
@@ -304,7 +306,8 @@ class TeamSessionDetailSchema(BaseModel):
     def from_session(cls, session: TeamSession) -> "TeamSessionDetailSchema":
         session_dict = session.to_dict()
         session_name = get_session_name({**session_dict, "session_type": "team"})
-
+        created_at = datetime.fromtimestamp(session.created_at, tz=timezone.utc) if session.created_at else None
+        updated_at = datetime.fromtimestamp(session.updated_at, tz=timezone.utc) if session.updated_at else created_at
         return cls(
             session_id=session.session_id,
             team_id=session.team_id,
@@ -319,8 +322,8 @@ class TeamSessionDetailSchema(BaseModel):
             metrics=session.session_data.get("session_metrics", {}) if session.session_data else None,
             metadata=session.metadata,
             chat_history=[message.to_dict() for message in session.get_chat_history()],
-            created_at=datetime.fromtimestamp(session.created_at, tz=timezone.utc) if session.created_at else None,
-            updated_at=datetime.fromtimestamp(session.updated_at, tz=timezone.utc) if session.updated_at else None,
+            created_at=created_at,
+            updated_at=updated_at,
         )
 
 
@@ -343,7 +346,6 @@ class WorkflowSessionDetailSchema(BaseModel):
     def from_session(cls, session: WorkflowSession) -> "WorkflowSessionDetailSchema":
         session_dict = session.to_dict()
         session_name = get_session_name({**session_dict, "session_type": "workflow"})
-
         return cls(
             session_id=session.session_id,
             user_id=session.user_id,
@@ -355,7 +357,7 @@ class WorkflowSessionDetailSchema(BaseModel):
             workflow_data=session.workflow_data,
             metadata=session.metadata,
             created_at=session.created_at,
-            updated_at=session.updated_at,
+            updated_at=session.updated_at or session.created_at,
         )
 
 

agno/run/__init__.py

@@ -1,6 +1,4 @@
 from agno.run.base import RunContext, RunStatus
+from agno.run.cancel import get_cancellation_manager, set_cancellation_manager
 
-__all__ = [
-    "RunContext",
-    "RunStatus",
-]
+__all__ = ["RunContext", "RunStatus", "get_cancellation_manager", "set_cancellation_manager"]

agno/run/agent.py

@@ -55,8 +55,11 @@ class RunInput:
             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])
+        elif isinstance(self.input_content, list):
+            try:
+                return json.dumps(self.to_dict().get("input_content"))
+            except Exception:
+                return str(self.input_content)
         else:
             return str(self.input_content)
 
@@ -71,22 +74,15 @@ class RunInput:
                 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()
-
-            # Handle input_content provided as a list of Message objects
-            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]
-
-            # Handle input_content provided as a list of dicts
-            elif (
-                isinstance(self.input_content, list) and self.input_content and isinstance(self.input_content[0], dict)
-            ):
-                for content in self.input_content:
-                    # Handle media input
-                    if isinstance(content, dict):
+            elif isinstance(self.input_content, list):
+                serialized_items: List[Any] = []
+                for item in self.input_content:
+                    if isinstance(item, Message):
+                        serialized_items.append(item.to_dict())
+                    elif isinstance(item, BaseModel):
+                        serialized_items.append(item.model_dump(exclude_none=True))
+                    elif isinstance(item, dict):
+                        content = dict(item)
                         if content.get("images"):
                             content["images"] = [
                                 img.to_dict() if isinstance(img, Image) else img for img in content["images"]
@@ -103,7 +99,11 @@ class RunInput:
                             content["files"] = [
                                 file.to_dict() if isinstance(file, File) else file for file in content["files"]
                             ]
-                result["input_content"] = self.input_content
+                        serialized_items.append(content)
+                    else:
+                        serialized_items.append(item)
+
+                result["input_content"] = serialized_items
             else:
                 result["input_content"] = self.input_content
 

agno/run/cancel.py

@@ -1,64 +1,37 @@
 """Run cancellation management."""
 
-import threading
 from typing import Dict
 
-from agno.exceptions import RunCancelledException
+from agno.run.cancellation_management.base import BaseRunCancellationManager
+from agno.run.cancellation_management.in_memory_cancellation_manager import InMemoryRunCancellationManager
 from agno.utils.log import logger
 
+# Global cancellation manager instance
+_cancellation_manager: BaseRunCancellationManager = InMemoryRunCancellationManager()
 
-class RunCancellationManager:
-    """Manages cancellation state for agent runs."""
-
-    def __init__(self):
-        self._cancelled_runs: Dict[str, bool] = {}
-        self._lock = threading.Lock()
-
-    def register_run(self, run_id: str) -> None:
-        """Register a new run as not cancelled."""
-        with self._lock:
-            self._cancelled_runs[run_id] = False
-
-    def cancel_run(self, run_id: str) -> bool:
-        """Cancel a run by marking it as cancelled.
-
-        Returns:
-            bool: True if run was found and cancelled, False if run not found.
-        """
-        with self._lock:
-            if run_id in self._cancelled_runs:
-                self._cancelled_runs[run_id] = True
-                logger.info(f"Run {run_id} marked for cancellation")
-                return True
-            else:
-                logger.warning(f"Attempted to cancel unknown run {run_id}")
-                return False
-
-    def is_cancelled(self, run_id: str) -> bool:
-        """Check if a run is cancelled."""
-        with self._lock:
-            return self._cancelled_runs.get(run_id, False)
-
-    def cleanup_run(self, run_id: str) -> None:
-        """Remove a run from tracking (called when run completes)."""
-        with self._lock:
-            if run_id in self._cancelled_runs:
-                del self._cancelled_runs[run_id]
-
-    def raise_if_cancelled(self, run_id: str) -> None:
-        """Check if a run should be cancelled and raise exception if so."""
-        if self.is_cancelled(run_id):
-            logger.info(f"Cancelling run {run_id}")
-            raise RunCancelledException(f"Run {run_id} was cancelled")
-
-    def get_active_runs(self) -> Dict[str, bool]:
-        """Get all currently tracked runs and their cancellation status."""
-        with self._lock:
-            return self._cancelled_runs.copy()
 
+def set_cancellation_manager(manager: BaseRunCancellationManager) -> None:
+    """Set a custom cancellation manager.
 
-# Global cancellation manager instance
-_cancellation_manager = RunCancellationManager()
+    Args:
+        manager: A BaseRunCancellationManager instance or subclass.
+
+    Example:
+        ```python
+        class MyCustomManager(BaseRunCancellationManager):
+            ....
+
+        set_cancellation_manager(MyCustomManager())
+        ```
+    """
+    global _cancellation_manager
+    _cancellation_manager = manager
+    logger.info(f"Cancellation manager set to {type(manager).__name__}")
+
+
+def get_cancellation_manager() -> BaseRunCancellationManager:
+    """Get the current cancellation manager instance."""
+    return _cancellation_manager
 
 
 def register_run(run_id: str) -> None:
@@ -66,16 +39,56 @@ def register_run(run_id: str) -> None:
     _cancellation_manager.register_run(run_id)
 
 
+async def aregister_run(run_id: str) -> None:
+    """Register a new run for cancellation tracking (async version)."""
+    await _cancellation_manager.aregister_run(run_id)
+
+
 def cancel_run(run_id: str) -> bool:
     """Cancel a run."""
     return _cancellation_manager.cancel_run(run_id)
 
 
+async def acancel_run(run_id: str) -> bool:
+    """Cancel a run (async version)."""
+    return await _cancellation_manager.acancel_run(run_id)
+
+
+def is_cancelled(run_id: str) -> bool:
+    """Check if a run is cancelled."""
+    return _cancellation_manager.is_cancelled(run_id)
+
+
+async def ais_cancelled(run_id: str) -> bool:
+    """Check if a run is cancelled (async version)."""
+    return await _cancellation_manager.ais_cancelled(run_id)
+
+
 def cleanup_run(run_id: str) -> None:
     """Clean up cancellation tracking for a completed run."""
     _cancellation_manager.cleanup_run(run_id)
 
 
+async def acleanup_run(run_id: str) -> None:
+    """Clean up cancellation tracking for a completed run (async version)."""
+    await _cancellation_manager.acleanup_run(run_id)
+
+
 def raise_if_cancelled(run_id: str) -> None:
     """Check if a run should be cancelled and raise exception if so."""
     _cancellation_manager.raise_if_cancelled(run_id)
+
+
+async def araise_if_cancelled(run_id: str) -> None:
+    """Check if a run should be cancelled and raise exception if so (async version)."""
+    await _cancellation_manager.araise_if_cancelled(run_id)
+
+
+def get_active_runs() -> Dict[str, bool]:
+    """Get all currently tracked runs and their cancellation status."""
+    return _cancellation_manager.get_active_runs()
+
+
+async def aget_active_runs() -> Dict[str, bool]:
+    """Get all currently tracked runs and their cancellation status (async version)."""
+    return await _cancellation_manager.aget_active_runs()

agno/run/cancellation_management/__init__.py

@@ -0,0 +1,9 @@
+from agno.run.cancellation_management.base import BaseRunCancellationManager
+from agno.run.cancellation_management.in_memory_cancellation_manager import InMemoryRunCancellationManager
+from agno.run.cancellation_management.redis_cancellation_manager import RedisRunCancellationManager
+
+__all__ = [
+    "BaseRunCancellationManager",
+    "InMemoryRunCancellationManager",
+    "RedisRunCancellationManager",
+]

agno/run/cancellation_management/base.py

@@ -0,0 +1,78 @@
+from abc import ABC, abstractmethod
+from typing import Dict
+
+
+class BaseRunCancellationManager(ABC):
+    """Manages cancellation state for agent runs.
+
+    This class can be extended to implement custom cancellation logic.
+    Use set_cancellation_manager() to replace the global instance with your own.
+    """
+
+    @abstractmethod
+    def register_run(self, run_id: str) -> None:
+        """Register a new run as not cancelled."""
+        pass
+
+    @abstractmethod
+    async def aregister_run(self, run_id: str) -> None:
+        """Register a new run as not cancelled (async version)."""
+        pass
+
+    @abstractmethod
+    def cancel_run(self, run_id: str) -> bool:
+        """Cancel a run by marking it as cancelled.
+
+        Returns:
+            bool: True if run was found and cancelled, False if run not found.
+        """
+        pass
+
+    @abstractmethod
+    async def acancel_run(self, run_id: str) -> bool:
+        """Cancel a run by marking it as cancelled (async version).
+
+        Returns:
+            bool: True if run was found and cancelled, False if run not found.
+        """
+        pass
+
+    @abstractmethod
+    def is_cancelled(self, run_id: str) -> bool:
+        """Check if a run is cancelled."""
+        pass
+
+    @abstractmethod
+    async def ais_cancelled(self, run_id: str) -> bool:
+        """Check if a run is cancelled (async version)."""
+        pass
+
+    @abstractmethod
+    def cleanup_run(self, run_id: str) -> None:
+        """Remove a run from tracking (called when run completes)."""
+        pass
+
+    @abstractmethod
+    async def acleanup_run(self, run_id: str) -> None:
+        """Remove a run from tracking (called when run completes) (async version)."""
+        pass
+
+    @abstractmethod
+    def raise_if_cancelled(self, run_id: str) -> None:
+        """Check if a run should be cancelled and raise exception if so."""
+        pass
+
+    @abstractmethod
+    async def araise_if_cancelled(self, run_id: str) -> None:
+        """Check if a run should be cancelled and raise exception if so (async version)."""
+        pass
+
+    @abstractmethod
+    def get_active_runs(self) -> Dict[str, bool]:
+        """Get all currently tracked runs and their cancellation status."""
+        pass
+
+    @abstractmethod
+    async def aget_active_runs(self) -> Dict[str, bool]:
+        """Get all currently tracked runs and their cancellation status (async version)."""
+        pass

agno/run/cancellation_management/in_memory_cancellation_manager.py

@@ -0,0 +1,100 @@
+"""Run cancellation management."""
+
+import asyncio
+import threading
+from typing import Dict
+
+from agno.exceptions import RunCancelledException
+from agno.run.cancellation_management.base import BaseRunCancellationManager
+from agno.utils.log import logger
+
+
+class InMemoryRunCancellationManager(BaseRunCancellationManager):
+    def __init__(self):
+        self._cancelled_runs: Dict[str, bool] = {}
+        self._lock = threading.Lock()
+        self._async_lock = asyncio.Lock()
+
+    def register_run(self, run_id: str) -> None:
+        """Register a new run as not cancelled."""
+        with self._lock:
+            self._cancelled_runs[run_id] = False
+
+    async def aregister_run(self, run_id: str) -> None:
+        """Register a new run as not cancelled (async version)."""
+        async with self._async_lock:
+            self._cancelled_runs[run_id] = False
+
+    def cancel_run(self, run_id: str) -> bool:
+        """Cancel a run by marking it as cancelled.
+
+        Returns:
+            bool: True if run was found and cancelled, False if run not found.
+        """
+        with self._lock:
+            if run_id in self._cancelled_runs:
+                self._cancelled_runs[run_id] = True
+                logger.info(f"Run {run_id} marked for cancellation")
+                return True
+            else:
+                logger.warning(f"Attempted to cancel unknown run {run_id}")
+                return False
+
+    async def acancel_run(self, run_id: str) -> bool:
+        """Cancel a run by marking it as cancelled (async version).
+
+        Returns:
+            bool: True if run was found and cancelled, False if run not found.
+        """
+        async with self._async_lock:
+            if run_id in self._cancelled_runs:
+                self._cancelled_runs[run_id] = True
+                logger.info(f"Run {run_id} marked for cancellation")
+                return True
+            else:
+                logger.warning(f"Attempted to cancel unknown run {run_id}")
+                return False
+
+    def is_cancelled(self, run_id: str) -> bool:
+        """Check if a run is cancelled."""
+        with self._lock:
+            return self._cancelled_runs.get(run_id, False)
+
+    async def ais_cancelled(self, run_id: str) -> bool:
+        """Check if a run is cancelled (async version)."""
+        async with self._async_lock:
+            return self._cancelled_runs.get(run_id, False)
+
+    def cleanup_run(self, run_id: str) -> None:
+        """Remove a run from tracking (called when run completes)."""
+        with self._lock:
+            if run_id in self._cancelled_runs:
+                del self._cancelled_runs[run_id]
+
+    async def acleanup_run(self, run_id: str) -> None:
+        """Remove a run from tracking (called when run completes) (async version)."""
+        async with self._async_lock:
+            if run_id in self._cancelled_runs:
+                del self._cancelled_runs[run_id]
+
+    def raise_if_cancelled(self, run_id: str) -> None:
+        """Check if a run should be cancelled and raise exception if so."""
+        if self.is_cancelled(run_id):
+            logger.info(f"Cancelling run {run_id}")
+            raise RunCancelledException(f"Run {run_id} was cancelled")
+
+    async def araise_if_cancelled(self, run_id: str) -> None:
+        """Check if a run should be cancelled and raise exception if so (async version)."""
+        if await self.ais_cancelled(run_id):
+            logger.info(f"Cancelling run {run_id}")
+            raise RunCancelledException(f"Run {run_id} was cancelled")
+
+    def get_active_runs(self) -> Dict[str, bool]:
+        """Get all currently tracked runs and their cancellation status."""
+        with self._lock:
+            return self._cancelled_runs.copy()
+
+    async def aget_active_runs(self) -> Dict[str, bool]:
+        """Get all currently tracked runs and their cancellation status (async version)."""
+        async with self._async_lock:
+            return self._cancelled_runs.copy()