agno 2.2.13__py3-none-any.whl

agno/run/base.py

@@ -0,0 +1,229 @@
+from dataclasses import asdict, dataclass
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel
+
+from agno.filters import FilterExpr
+from agno.media import Audio, Image, Video
+from agno.models.message import Citations, Message, MessageReferences
+from agno.models.metrics import Metrics
+from agno.reasoning.step import ReasoningStep
+from agno.utils.log import log_error
+
+
+@dataclass
+class RunContext:
+    run_id: str
+    session_id: str
+    user_id: Optional[str] = None
+
+    dependencies: Optional[Dict[str, Any]] = None
+    knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
+    metadata: Optional[Dict[str, Any]] = None
+    session_state: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class BaseRunOutputEvent:
+    def to_dict(self) -> Dict[str, Any]:
+        _dict = {
+            k: v
+            for k, v in asdict(self).items()
+            if v is not None
+            and k
+            not in [
+                "tools",
+                "tool",
+                "metadata",
+                "image",
+                "images",
+                "videos",
+                "audio",
+                "response_audio",
+                "citations",
+                "member_responses",
+                "reasoning_messages",
+                "reasoning_steps",
+                "references",
+                "additional_input",
+                "session_summary",
+                "metrics",
+            ]
+        }
+
+        if hasattr(self, "metadata") and self.metadata is not None:
+            _dict["metadata"] = self.metadata
+
+        if hasattr(self, "additional_input") and self.additional_input is not None:
+            _dict["additional_input"] = [m.to_dict() for m in self.additional_input]
+
+        if hasattr(self, "reasoning_messages") and self.reasoning_messages is not None:
+            _dict["reasoning_messages"] = [m.to_dict() for m in self.reasoning_messages]
+
+        if hasattr(self, "reasoning_steps") and self.reasoning_steps is not None:
+            _dict["reasoning_steps"] = [rs.model_dump() for rs in self.reasoning_steps]
+
+        if hasattr(self, "references") and self.references is not None:
+            _dict["references"] = [r.model_dump() for r in self.references]
+
+        if hasattr(self, "member_responses") and self.member_responses:
+            _dict["member_responses"] = [response.to_dict() for response in self.member_responses]
+
+        if hasattr(self, "images") and self.images is not None:
+            _dict["images"] = []
+            for img in self.images:
+                if isinstance(img, Image):
+                    _dict["images"].append(img.to_dict())
+                else:
+                    _dict["images"].append(img)
+
+        if hasattr(self, "videos") and self.videos is not None:
+            _dict["videos"] = []
+            for vid in self.videos:
+                if isinstance(vid, Video):
+                    _dict["videos"].append(vid.to_dict())
+                else:
+                    _dict["videos"].append(vid)
+
+        if hasattr(self, "audio") and self.audio is not None:
+            _dict["audio"] = []
+            for aud in self.audio:
+                if isinstance(aud, Audio):
+                    _dict["audio"].append(aud.to_dict())
+                else:
+                    _dict["audio"].append(aud)
+
+        if hasattr(self, "response_audio") and self.response_audio is not None:
+            if isinstance(self.response_audio, Audio):
+                _dict["response_audio"] = self.response_audio.to_dict()
+            else:
+                _dict["response_audio"] = self.response_audio
+
+        if hasattr(self, "citations") and self.citations is not None:
+            if isinstance(self.citations, Citations):
+                _dict["citations"] = self.citations.model_dump(exclude_none=True)
+            else:
+                _dict["citations"] = self.citations
+
+        if hasattr(self, "content") and self.content and isinstance(self.content, BaseModel):
+            _dict["content"] = self.content.model_dump(exclude_none=True)
+
+        if hasattr(self, "tools") and self.tools is not None:
+            from agno.models.response import ToolExecution
+
+            _dict["tools"] = []
+            for tool in self.tools:
+                if isinstance(tool, ToolExecution):
+                    _dict["tools"].append(tool.to_dict())
+                else:
+                    _dict["tools"].append(tool)
+
+        if hasattr(self, "tool") and self.tool is not None:
+            from agno.models.response import ToolExecution
+
+            if isinstance(self.tool, ToolExecution):
+                _dict["tool"] = self.tool.to_dict()
+            else:
+                _dict["tool"] = self.tool
+
+        if hasattr(self, "metrics") and self.metrics is not None:
+            _dict["metrics"] = self.metrics.to_dict()
+
+        if hasattr(self, "session_summary") and self.session_summary is not None:
+            _dict["session_summary"] = self.session_summary.to_dict()
+
+        return _dict
+
+    def to_json(self, separators=(", ", ": "), indent: Optional[int] = 2) -> str:
+        import json
+
+        from agno.utils.serialize import json_serializer
+
+        try:
+            _dict = self.to_dict()
+        except Exception:
+            log_error("Failed to convert response event to json", exc_info=True)
+            raise
+
+        if indent is None:
+            return json.dumps(_dict, separators=separators, default=json_serializer, ensure_ascii=False)
+        else:
+            return json.dumps(_dict, indent=indent, separators=separators, default=json_serializer, ensure_ascii=False)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]):
+        tool = data.pop("tool", None)
+        if tool:
+            from agno.models.response import ToolExecution
+
+            data["tool"] = ToolExecution.from_dict(tool)
+
+        images = data.pop("images", None)
+        if images:
+            data["images"] = [Image.model_validate(image) for image in images]
+
+        videos = data.pop("videos", None)
+        if videos:
+            data["videos"] = [Video.model_validate(video) for video in videos]
+
+        audio = data.pop("audio", None)
+        if audio:
+            data["audio"] = [Audio.model_validate(audio) for audio in audio]
+
+        response_audio = data.pop("response_audio", None)
+        if response_audio:
+            data["response_audio"] = Audio.model_validate(response_audio)
+
+        additional_input = data.pop("additional_input", None)
+        if additional_input is not None:
+            data["additional_input"] = [Message.model_validate(message) for message in additional_input]
+
+        reasoning_steps = data.pop("reasoning_steps", None)
+        if reasoning_steps is not None:
+            data["reasoning_steps"] = [ReasoningStep.model_validate(step) for step in reasoning_steps]
+
+        reasoning_messages = data.pop("reasoning_messages", None)
+        if reasoning_messages is not None:
+            data["reasoning_messages"] = [Message.model_validate(message) for message in reasoning_messages]
+
+        references = data.pop("references", None)
+        if references is not None:
+            data["references"] = [MessageReferences.model_validate(reference) for reference in references]
+
+        metrics = data.pop("metrics", None)
+        if metrics:
+            data["metrics"] = Metrics(**metrics)
+
+        session_summary = data.pop("session_summary", None)
+        if session_summary:
+            from agno.session.summary import SessionSummary
+
+            data["session_summary"] = SessionSummary.from_dict(session_summary)
+
+        # Filter data to only include fields that are actually defined in the target class
+        from dataclasses import fields
+
+        supported_fields = {f.name for f in fields(cls)}
+        filtered_data = {k: v for k, v in data.items() if k in supported_fields}
+
+        return cls(**filtered_data)
+
+    @property
+    def is_paused(self):
+        return False
+
+    @property
+    def is_cancelled(self):
+        return False
+
+
+class RunStatus(str, Enum):
+    """State of the main run response"""
+
+    pending = "PENDING"
+    running = "RUNNING"
+    completed = "COMPLETED"
+    paused = "PAUSED"
+    cancelled = "CANCELLED"
+    error = "ERROR"

agno/run/cancel.py

@@ -0,0 +1,81 @@
+"""Run cancellation management."""
+
+import threading
+from typing import Dict
+
+from agno.exceptions import RunCancelledException
+from agno.utils.log import logger
+
+
+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()
+
+
+# Global cancellation manager instance
+_cancellation_manager = RunCancellationManager()
+
+
+def register_run(run_id: str) -> None:
+    """Register a new run for cancellation tracking."""
+    _cancellation_manager.register_run(run_id)
+
+
+def cancel_run(run_id: str) -> bool:
+    """Cancel a run."""
+    return _cancellation_manager.cancel_run(run_id)
+
+
+def cleanup_run(run_id: str) -> None:
+    """Clean up cancellation tracking for a completed run."""
+    _cancellation_manager.cleanup_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)

agno/run/messages.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from agno.models.message import Message
+
+
+@dataclass
+class RunMessages:
+    """Container for messages used in an Agent run.
+
+    Attributes:
+        messages: List of all messages to send to the model
+        system_message: The system message for this run
+        user_message: The user message for this run
+        extra_messages: Extra messages added after the system and user messages
+    """
+
+    messages: List[Message] = field(default_factory=list)
+    system_message: Optional[Message] = None
+    user_message: Optional[Message] = None
+    extra_messages: Optional[List[Message]] = None
+
+    def get_input_messages(self) -> List[Message]:
+        """Get the input messages for the model."""
+        input_messages = []
+        if self.system_message is not None:
+            input_messages.append(self.system_message)
+        if self.user_message is not None:
+            input_messages.append(self.user_message)
+        if self.extra_messages is not None:
+            input_messages.extend(self.extra_messages)
+        return input_messages