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

agno/models/openai/chat.py

@@ -820,6 +820,16 @@ class OpenAIChat(Model):
         if response.usage is not None:
             model_response.response_usage = self._get_metrics(response.usage)
 
+        if model_response.provider_data is None:
+            model_response.provider_data = {}
+
+        if response.id:
+            model_response.provider_data["id"] = response.id
+        if response.system_fingerprint:
+            model_response.provider_data["system_fingerprint"] = response.system_fingerprint
+        if response.model_extra:
+            model_response.provider_data["model_extra"] = response.model_extra
+
         return model_response
 
     def _parse_provider_response_delta(self, response_delta: ChatCompletionChunk) -> ModelResponse:
@@ -842,6 +852,17 @@ class OpenAIChat(Model):
                 if choice_delta.content is not None:
                     model_response.content = choice_delta.content
 
+                    # We only want to handle these if content is present
+                    if model_response.provider_data is None:
+                        model_response.provider_data = {}
+
+                    if response_delta.id:
+                        model_response.provider_data["id"] = response_delta.id
+                    if response_delta.system_fingerprint:
+                        model_response.provider_data["system_fingerprint"] = response_delta.system_fingerprint
+                    if response_delta.model_extra:
+                        model_response.provider_data["model_extra"] = response_delta.model_extra
+
                 # Add tool calls
                 if choice_delta.tool_calls is not None:
                     model_response.tool_calls = choice_delta.tool_calls  # type: ignore

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

@@ -1,7 +1,7 @@
 import json
 import logging
 import math
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from fastapi import APIRouter, BackgroundTasks, Depends, File, Form, HTTPException, Path, Query, UploadFile
 
@@ -874,8 +874,8 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
     ) -> ConfigResponseSchema:
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
 
-        # Get factory readers info
-        readers_info = get_all_readers_info()
+        # Get factory readers info (including custom readers from this knowledge instance)
+        readers_info = get_all_readers_info(knowledge)
         reader_schemas = {}
         # Add factory readers
         for reader_info in readers_info:
@@ -887,7 +887,12 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             )
 
         # Add custom readers from knowledge.readers
-        readers_dict: Dict[str, Reader] = knowledge.get_readers() or {}
+        readers_result: Any = knowledge.get_readers() or {}
+        # Ensure readers_dict is a dictionary (defensive check)
+        if not isinstance(readers_result, dict):
+            readers_dict: Dict[str, Reader] = {}
+        else:
+            readers_dict = readers_result
         if readers_dict:
             for reader_id, reader in readers_dict.items():
                 # Get chunking strategies from the reader
@@ -907,8 +912,8 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
                         chunkers=chunking_strategies,
                     )
 
-        # Get content types to readers mapping
-        types_of_readers = get_content_types_to_readers_mapping()
+        # Get content types to readers mapping (including custom readers from this knowledge instance)
+        types_of_readers = get_content_types_to_readers_mapping(knowledge)
         chunkers_list = get_all_chunkers_info()
 
         # Convert chunkers list to dictionary format expected by schema
@@ -961,20 +966,26 @@ async def process_content(
     try:
         if reader_id:
             reader = None
-            if knowledge.readers and reader_id in knowledge.readers:
-                reader = knowledge.readers[reader_id]
+            # Use get_readers() to ensure we get a dict (handles list conversion)
+            custom_readers = knowledge.get_readers()
+            if custom_readers and reader_id in custom_readers:
+                reader = custom_readers[reader_id]
+                log_debug(f"Found custom reader: {reader.__class__.__name__}")
             else:
+                # Try to resolve from factory readers
                 key = reader_id.lower().strip().replace("-", "_").replace(" ", "_")
                 candidates = [key] + ([key[:-6]] if key.endswith("reader") else [])
                 for cand in candidates:
                     try:
                         reader = ReaderFactory.create_reader(cand)
-                        log_debug(f"Resolved reader: {reader.__class__.__name__}")
+                        log_debug(f"Resolved reader from factory: {reader.__class__.__name__}")
                         break
                     except Exception:
                         continue
             if reader:
                 content.reader = reader
+            else:
+                log_debug(f"Could not resolve reader with id: {reader_id}")
         if chunker and content.reader:
             # Set the chunker name on the reader - let the reader handle it internally
             content.reader.set_chunking_strategy_from_string(chunker, chunk_size=chunk_size, overlap=chunk_overlap)

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/tracing/exporter.py

@@ -90,7 +90,7 @@ class DatabaseSpanExporter(SpanExporter):
                 # Create trace record (aggregate of all spans)
                 trace = create_trace_from_spans(spans)
                 if trace:
-                    self.db.create_trace(trace)
+                    self.db.upsert_trace(trace)
 
                 # Create span records
                 self.db.create_spans(spans)
@@ -124,7 +124,7 @@ class DatabaseSpanExporter(SpanExporter):
                 # Create trace record (aggregate of all spans)
                 trace = create_trace_from_spans(spans)
                 if trace:
-                    create_trace_result = self.db.create_trace(trace)
+                    create_trace_result = self.db.upsert_trace(trace)
                     if create_trace_result is not None:
                         await create_trace_result
 

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(