agno 2.3.11__py3-none-any.whl → 2.3.12__py3-none-any.whl

agno/models/openai/responses.py

@@ -17,6 +17,7 @@ from agno.utils.http import get_default_async_client, get_default_sync_client
 from agno.utils.log import log_debug, log_error, log_warning
 from agno.utils.models.openai_responses import images_to_message
 from agno.utils.models.schema_utils import get_response_schema_for_provider
+from agno.utils.tokens import count_schema_tokens
 
 try:
     from openai import APIConnectionError, APIStatusError, AsyncOpenAI, OpenAI, RateLimitError
@@ -520,6 +521,49 @@ class OpenAIResponses(Model):
                         formatted_messages.append(reasoning_output)
         return formatted_messages
 
+    def count_tokens(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict[str, Any]]] = None,
+        output_schema: Optional[Union[Dict, Type[BaseModel]]] = None,
+    ) -> int:
+        try:
+            formatted_input = self._format_messages(messages, compress_tool_results=True)
+            formatted_tools = self._format_tool_params(messages, tools) if tools else None
+
+            response = self.get_client().responses.input_tokens.count(
+                model=self.id,
+                input=formatted_input,  # type: ignore
+                instructions=self.instructions,  # type: ignore
+                tools=formatted_tools,  # type: ignore
+            )
+            return response.input_tokens + count_schema_tokens(output_schema, self.id)
+        except Exception as e:
+            log_warning(f"Failed to count tokens via API: {e}")
+            return super().count_tokens(messages, tools, output_schema)
+
+    async def acount_tokens(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict[str, Any]]] = None,
+        output_schema: Optional[Union[Dict, Type[BaseModel]]] = None,
+    ) -> int:
+        """Async version of count_tokens using the async client."""
+        try:
+            formatted_input = self._format_messages(messages, compress_tool_results=True)
+            formatted_tools = self._format_tool_params(messages, tools) if tools else None
+
+            response = await self.get_async_client().responses.input_tokens.count(
+                model=self.id,
+                input=formatted_input,  # type: ignore
+                instructions=self.instructions,  # type: ignore
+                tools=formatted_tools,  # type: ignore
+            )
+            return response.input_tokens + count_schema_tokens(output_schema, self.id)
+        except Exception as e:
+            log_warning(f"Failed to count tokens via API: {e}")
+            return await super().acount_tokens(messages, tools, output_schema)
+
     def invoke(
         self,
         messages: List[Message],

agno/os/routers/knowledge/knowledge.py

@@ -888,7 +888,6 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
 
         # Add custom readers from knowledge.readers
         readers_result: Any = knowledge.get_readers() or {}
-        print(f"readers_result: {readers_result}")
         # Ensure readers_dict is a dictionary (defensive check)
         if not isinstance(readers_result, dict):
             readers_dict: Dict[str, Reader] = {}

agno/run/agent.py

@@ -604,6 +604,7 @@ class RunOutput:
                 "reasoning_steps",
                 "reasoning_messages",
                 "references",
+                "requirements",
             ]
         }
 
@@ -689,6 +690,9 @@ class RunOutput:
                 else:
                     _dict["tools"].append(tool)
 
+        if self.requirements is not None:
+            _dict["requirements"] = [req.to_dict() if hasattr(req, "to_dict") else req for req in self.requirements]
+
         if self.input is not None:
             _dict["input"] = self.input.to_dict()
 
@@ -735,6 +739,18 @@ class RunOutput:
         tools = data.pop("tools", [])
         tools = [ToolExecution.from_dict(tool) for tool in tools] if tools else None
 
+        # Handle requirements
+        requirements_data = data.pop("requirements", None)
+        requirements: Optional[List[RunRequirement]] = None
+        if requirements_data is not None:
+            requirements_list: List[RunRequirement] = []
+            for item in requirements_data:
+                if isinstance(item, RunRequirement):
+                    requirements_list.append(item)
+                elif isinstance(item, dict):
+                    requirements_list.append(RunRequirement.from_dict(item))
+            requirements = requirements_list if requirements_list else None
+
         images = reconstruct_images(data.pop("images", []))
         videos = reconstruct_videos(data.pop("videos", []))
         audio = reconstruct_audio_list(data.pop("audio", []))
@@ -789,6 +805,7 @@ class RunOutput:
             reasoning_steps=reasoning_steps,
             reasoning_messages=reasoning_messages,
             references=references,
+            requirements=requirements,
             **filtered_data,
         )
 

agno/run/requirement.py

@@ -1,6 +1,6 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 from uuid import uuid4
 
 from agno.models.response import ToolExecution, UserInputField
@@ -14,7 +14,7 @@ class RunRequirement:
     """Requirement to complete a paused run (used in HITL flows)"""
 
     tool_execution: Optional[ToolExecution] = None
-    created_at: datetime = datetime.now(timezone.utc)
+    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
 
     # User confirmation
     confirmation: Optional[bool] = None
@@ -26,10 +26,19 @@ class RunRequirement:
     # External execution
     external_execution_result: Optional[str] = None
 
-    def __init__(self, tool_execution: ToolExecution):
-        self.id = str(uuid4())
+    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
+        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:
@@ -96,3 +105,77 @@ class RunRequirement:
     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

agno/utils/print_response/agent.py

@@ -469,8 +469,8 @@ def build_panels_stream(
             stats = compression_manager.stats
             saved = stats.get("original_size", 0) - stats.get("compressed_size", 0)
             orig = stats.get("original_size", 1)
-            if stats.get("messages_compressed", 0) > 0:
-                tool_calls_text += f"\n\nTool results compressed: {stats.get('messages_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
+            if stats.get("tool_results_compressed", 0) > 0:
+                tool_calls_text += f"\n\ncompressed: {stats.get('tool_results_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
 
         tool_calls_panel = create_panel(
             content=tool_calls_text,
@@ -847,8 +847,8 @@ def build_panels(
             stats = compression_manager.stats
             saved = stats.get("original_size", 0) - stats.get("compressed_size", 0)
             orig = stats.get("original_size", 1)
-            if stats.get("messages_compressed", 0) > 0:
-                tool_calls_text += f"\n\nTool results compressed: {stats.get('messages_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
+            if stats.get("tool_results_compressed", 0) > 0:
+                tool_calls_text += f"\n\ncompressed: {stats.get('tool_results_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
             compression_manager.stats.clear()
 
         tool_calls_panel = create_panel(

agno/utils/print_response/team.py

@@ -267,8 +267,8 @@ def print_response(
                         stats = team.compression_manager.stats
                         saved = stats.get("original_size", 0) - stats.get("compressed_size", 0)
                         orig = stats.get("original_size", 1)
-                        if stats.get("messages_compressed", 0) > 0:
-                            tool_calls_text += f"\n\nTool results compressed: {stats.get('messages_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
+                        if stats.get("tool_results_compressed", 0) > 0:
+                            tool_calls_text += f"\n\ncompressed: {stats.get('tool_results_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
                         team.compression_manager.stats.clear()
 
                     team_tool_calls_panel = create_panel(
@@ -631,8 +631,8 @@ def print_response_stream(
                         stats = team.compression_manager.stats
                         saved = stats.get("original_size", 0) - stats.get("compressed_size", 0)
                         orig = stats.get("original_size", 1)
-                        if stats.get("messages_compressed", 0) > 0:
-                            tool_calls_text += f"\n\nTool results compressed: {stats.get('messages_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
+                        if stats.get("tool_results_compressed", 0) > 0:
+                            tool_calls_text += f"\n\ncompressed: {stats.get('tool_results_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
 
                     team_tool_calls_panel = create_panel(
                         content=tool_calls_text,
@@ -841,8 +841,8 @@ def print_response_stream(
                     stats = team.compression_manager.stats
                     saved = stats.get("original_size", 0) - stats.get("compressed_size", 0)
                     orig = stats.get("original_size", 1)
-                    if stats.get("messages_compressed", 0) > 0:
-                        tool_calls_text += f"\n\nTool results compressed: {stats.get('messages_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
+                    if stats.get("tool_results_compressed", 0) > 0:
+                        tool_calls_text += f"\n\ncompressed: {stats.get('tool_results_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
                     team.compression_manager.stats.clear()
 
                 team_tool_calls_panel = create_panel(
@@ -1132,8 +1132,8 @@ async def aprint_response(
                         stats = team.compression_manager.stats
                         saved = stats.get("original_size", 0) - stats.get("compressed_size", 0)
                         orig = stats.get("original_size", 1)
-                        if stats.get("messages_compressed", 0) > 0:
-                            tool_calls_text += f"\n\nTool results compressed: {stats.get('messages_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
+                        if stats.get("tool_results_compressed", 0) > 0:
+                            tool_calls_text += f"\n\ncompressed: {stats.get('tool_results_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
                         team.compression_manager.stats.clear()
 
                     team_tool_calls_panel = create_panel(
@@ -1494,8 +1494,8 @@ async def aprint_response_stream(
                         stats = team.compression_manager.stats
                         saved = stats.get("original_size", 0) - stats.get("compressed_size", 0)
                         orig = stats.get("original_size", 1)
-                        if stats.get("messages_compressed", 0) > 0:
-                            tool_calls_text += f"\n\nTool results compressed: {stats.get('messages_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
+                        if stats.get("tool_results_compressed", 0) > 0:
+                            tool_calls_text += f"\n\ncompressed: {stats.get('tool_results_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
 
                     team_tool_calls_panel = create_panel(
                         content=tool_calls_text,
@@ -1722,8 +1722,8 @@ async def aprint_response_stream(
                     stats = team.compression_manager.stats
                     saved = stats.get("original_size", 0) - stats.get("compressed_size", 0)
                     orig = stats.get("original_size", 1)
-                    if stats.get("messages_compressed", 0) > 0:
-                        tool_calls_text += f"\n\nTool results compressed: {stats.get('messages_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
+                    if stats.get("tool_results_compressed", 0) > 0:
+                        tool_calls_text += f"\n\ncompressed: {stats.get('tool_results_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
                     team.compression_manager.stats.clear()
 
                 team_tool_calls_panel = create_panel(