agno 0.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/run/base.py

@@ -0,0 +1,247 @@
+from dataclasses import asdict, dataclass
+from enum import Enum
+from typing import Any, Dict, List, Optional, Type, 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
+    output_schema: Optional[Type[BaseModel]] = 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",
+                "run_input",
+            ]
+        }
+
+        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()
+
+        if hasattr(self, "run_input") and self.run_input is not None:
+            _dict["run_input"] = self.run_input.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)
+
+        run_input = data.pop("run_input", None)
+        if run_input:
+            from agno.run.team import BaseTeamRunEvent
+
+            if issubclass(cls, BaseTeamRunEvent):
+                from agno.run.team import TeamRunInput
+
+                data["run_input"] = TeamRunInput.from_dict(run_input)
+            else:
+                from agno.run.agent import RunInput
+
+                data["run_input"] = RunInput.from_dict(run_input)
+
+        # 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/requirement.py

@@ -0,0 +1,181 @@
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from uuid import uuid4
+
+from agno.models.response import ToolExecution, UserInputField
+
+if TYPE_CHECKING:
+    pass
+
+
+@dataclass
+class RunRequirement:
+    """Requirement to complete a paused run (used in HITL flows)"""
+
+    tool_execution: Optional[ToolExecution] = None
+    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+    # User confirmation
+    confirmation: Optional[bool] = None
+    confirmation_note: Optional[str] = None
+
+    # User input
+    user_input_schema: Optional[List[UserInputField]] = None
+
+    # External execution
+    external_execution_result: Optional[str] = None
+
+    def __init__(
+        self,
+        tool_execution: ToolExecution,
+        id: Optional[str] = None,
+        created_at: Optional[datetime] = None,
+    ):
+        self.id = id or str(uuid4())
+        self.tool_execution = tool_execution
+        self.user_input_schema = tool_execution.user_input_schema if tool_execution else None
+        self.created_at = created_at or datetime.now(timezone.utc)
+        self.confirmation = None
+        self.confirmation_note = None
+        self.external_execution_result = None
+
+    @property
+    def needs_confirmation(self) -> bool:
+        if self.confirmation is not None:
+            return False
+        if not self.tool_execution:
+            return False
+        if self.tool_execution.confirmed is True:
+            return True
+
+        return self.tool_execution.requires_confirmation or False
+
+    @property
+    def needs_user_input(self) -> bool:
+        if not self.tool_execution:
+            return False
+        if self.tool_execution.answered is True:
+            return False
+        if self.user_input_schema and not all(field.value is not None for field in self.user_input_schema):
+            return True
+
+        return self.tool_execution.requires_user_input or False
+
+    @property
+    def needs_external_execution(self) -> bool:
+        if not self.tool_execution:
+            return False
+        if self.external_execution_result is not None:
+            return True
+
+        return self.tool_execution.external_execution_required or False
+
+    def confirm(self):
+        if not self.needs_confirmation:
+            raise ValueError("This requirement does not require confirmation")
+        self.confirmation = True
+        if self.tool_execution:
+            self.tool_execution.confirmed = True
+
+    def reject(self):
+        if not self.needs_confirmation:
+            raise ValueError("This requirement does not require confirmation")
+        self.confirmation = False
+        if self.tool_execution:
+            self.tool_execution.confirmed = False
+
+    def set_external_execution_result(self, result: str):
+        if not self.needs_external_execution:
+            raise ValueError("This requirement does not require external execution")
+        self.external_execution_result = result
+        if self.tool_execution:
+            self.tool_execution.result = result
+
+    def update_tool(self):
+        if not self.tool_execution:
+            return
+        if self.confirmation is True:
+            self.tool_execution.confirmed = True
+        elif self.confirmation is False:
+            self.tool_execution.confirmed = False
+        else:
+            raise ValueError("This requirement does not require confirmation or user input")
+
+    def is_resolved(self) -> bool:
+        """Return True if the requirement has been resolved"""
+        return not self.needs_confirmation and not self.needs_user_input and not self.needs_external_execution
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to JSON-serializable dictionary for storage."""
+        _dict: Dict[str, Any] = {
+            "id": self.id,
+            "created_at": self.created_at.isoformat() if isinstance(self.created_at, datetime) else self.created_at,
+            "confirmation": self.confirmation,
+            "confirmation_note": self.confirmation_note,
+            "external_execution_result": self.external_execution_result,
+        }
+
+        if self.tool_execution is not None:
+            _dict["tool_execution"] = (
+                self.tool_execution.to_dict() if isinstance(self.tool_execution, ToolExecution) else self.tool_execution
+            )
+
+        if self.user_input_schema is not None:
+            _dict["user_input_schema"] = [f.to_dict() if hasattr(f, "to_dict") else f for f in self.user_input_schema]
+
+        return {k: v for k, v in _dict.items() if v is not None}
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "RunRequirement":
+        """Reconstruct from stored dictionary."""
+        if data is None:
+            raise ValueError("RunRequirement.from_dict() requires a non-None dict")
+
+        # Handle tool_execution
+        tool_data = data.get("tool_execution")
+        tool_execution: Optional[ToolExecution] = None
+        if isinstance(tool_data, ToolExecution):
+            tool_execution = tool_data
+        elif isinstance(tool_data, dict):
+            tool_execution = ToolExecution.from_dict(tool_data)
+
+        # Handle created_at (ISO string or datetime)
+        created_at_raw = data.get("created_at")
+        created_at: Optional[datetime] = None
+        if isinstance(created_at_raw, datetime):
+            created_at = created_at_raw
+        elif isinstance(created_at_raw, str):
+            try:
+                created_at = datetime.fromisoformat(created_at_raw)
+            except ValueError:
+                created_at = None
+
+        # Build requirement - tool_execution is required by __init__
+        # For legacy data without tool_execution, create a minimal placeholder
+        if tool_execution is None:
+            tool_execution = ToolExecution(tool_name="unknown", tool_args={})
+
+        requirement = cls(
+            tool_execution=tool_execution,
+            id=data.get("id"),
+            created_at=created_at,
+        )
+
+        # Set optional fields
+        requirement.confirmation = data.get("confirmation")
+        requirement.confirmation_note = data.get("confirmation_note")
+        requirement.external_execution_result = data.get("external_execution_result")
+
+        # Handle user_input_schema
+        schema_raw = data.get("user_input_schema")
+        if schema_raw is not None:
+            rebuilt_schema: List[UserInputField] = []
+            for item in schema_raw:
+                if isinstance(item, UserInputField):
+                    rebuilt_schema.append(item)
+                elif isinstance(item, dict):
+                    rebuilt_schema.append(UserInputField.from_dict(item))
+            requirement.user_input_schema = rebuilt_schema if rebuilt_schema else None
+
+        return requirement