agno 2.3.26__py3-none-any.whl → 2.4.0__py3-none-any.whl

agno/learn/stores/learned_knowledge.py

@@ -919,7 +919,7 @@ class LearnedKnowledgeStore(LearningStore):
             text_content = self._to_text_content(learning=learning_obj)
 
             # Build metadata for filtering
-            # Metadata must be passed separately to add_content for filters to work
+            # Metadata must be passed separately to insert for filters to work
             filter_metadata: dict[str, Any] = {
                 "namespace": effective_namespace,
             }
@@ -932,7 +932,7 @@ class LearnedKnowledgeStore(LearningStore):
             if tags:
                 filter_metadata["tags"] = tags
 
-            self.knowledge.add_content(
+            self.knowledge.insert(
                 name=learning_data["title"],
                 text_content=text_content,
                 reader=TextReader(),
@@ -989,7 +989,7 @@ class LearnedKnowledgeStore(LearningStore):
             text_content = self._to_text_content(learning=learning_obj)
 
             # Build metadata for filtering - THIS IS THE KEY FIX!
-            # Metadata must be passed separately to add_content for filters to work
+            # Metadata must be passed separately to insert for filters to work
             filter_metadata: dict[str, Any] = {
                 "namespace": effective_namespace,
             }
@@ -1002,8 +1002,8 @@ class LearnedKnowledgeStore(LearningStore):
             if tags:
                 filter_metadata["tags"] = tags
 
-            if hasattr(self.knowledge, "aadd_content"):
-                await self.knowledge.aadd_content(
+            if hasattr(self.knowledge, "ainsert"):
+                await self.knowledge.ainsert(
                     name=learning_data["title"],
                     text_content=text_content,
                     reader=TextReader(),
@@ -1011,7 +1011,7 @@ class LearnedKnowledgeStore(LearningStore):
                     metadata=filter_metadata,  # Pass metadata for filtering
                 )
             else:
-                self.knowledge.add_content(
+                self.knowledge.insert(
                     name=learning_data["title"],
                     text_content=text_content,
                     reader=TextReader(),

agno/models/anthropic/claude.py

@@ -406,6 +406,30 @@ class Claude(Model):
         self.async_client = AsyncAnthropicClient(**_client_params)
         return self.async_client
 
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the model to a dictionary.
+
+        Returns:
+            Dict[str, Any]: The dictionary representation of the model.
+        """
+        model_dict = super().to_dict()
+        model_dict.update(
+            {
+                "max_tokens": self.max_tokens,
+                "thinking": self.thinking,
+                "temperature": self.temperature,
+                "stop_sequences": self.stop_sequences,
+                "top_p": self.top_p,
+                "top_k": self.top_k,
+                "cache_system_prompt": self.cache_system_prompt,
+                "extended_cache_time": self.extended_cache_time,
+                "betas": self.betas,
+            }
+        )
+        cleaned_dict = {k: v for k, v in model_dict.items() if v is not None}
+        return cleaned_dict
+
     def count_tokens(
         self,
         messages: List[Message],

agno/models/aws/bedrock.py

@@ -166,6 +166,26 @@ class AwsBedrock(Model):
 
         return self.async_session.client(**client_kwargs)
 
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the model to a dictionary.
+
+        Returns:
+            Dict[str, Any]: The dictionary representation of the model.
+        """
+        model_dict = super().to_dict()
+        model_dict.update(
+            {
+                "aws_region": self.aws_region,
+                "max_tokens": self.max_tokens,
+                "temperature": self.temperature,
+                "top_p": self.top_p,
+                "stop_sequences": self.stop_sequences,
+            }
+        )
+        cleaned_dict = {k: v for k, v in model_dict.items() if v is not None}
+        return cleaned_dict
+
     def _format_tools_for_request(self, tools: Optional[List[Dict[str, Any]]]) -> List[Dict[str, Any]]:
         """
         Format the tools for the request.

agno/models/base.py

@@ -1293,12 +1293,23 @@ class Model(ABC):
                 if _compression_manager is not None and _compression_manager.should_compress(
                     messages, tools, model=self, response_format=response_format
                 ):
+                    # Emit compression started event
+                    yield ModelResponse(event=ModelResponseEvent.compression_started.value)
                     _compression_manager.compress(messages)
+                    # Emit compression completed event with stats
+                    yield ModelResponse(
+                        event=ModelResponseEvent.compression_completed.value,
+                        compression_stats=_compression_manager.stats.copy(),
+                    )
 
                 assistant_message = Message(role=self.assistant_message_role)
                 # Create assistant message and stream data
                 stream_data = MessageData()
                 model_response = ModelResponse()
+
+                # Emit LLM request started event
+                yield ModelResponse(event=ModelResponseEvent.model_request_started.value)
+
                 if stream_model_response:
                     # Generate response
                     for response in self.process_response_stream(
@@ -1334,6 +1345,19 @@ class Model(ABC):
                 messages.append(assistant_message)
                 assistant_message.log(metrics=True)
 
+                # Emit LLM request completed event with metrics
+                llm_metrics = assistant_message.metrics
+                yield ModelResponse(
+                    event=ModelResponseEvent.model_request_completed.value,
+                    input_tokens=llm_metrics.input_tokens if llm_metrics else None,
+                    output_tokens=llm_metrics.output_tokens if llm_metrics else None,
+                    total_tokens=llm_metrics.total_tokens if llm_metrics else None,
+                    time_to_first_token=llm_metrics.time_to_first_token if llm_metrics else None,
+                    reasoning_tokens=llm_metrics.reasoning_tokens if llm_metrics else None,
+                    cache_read_tokens=llm_metrics.cache_read_tokens if llm_metrics else None,
+                    cache_write_tokens=llm_metrics.cache_write_tokens if llm_metrics else None,
+                )
+
                 # Handle tool calls if present
                 if assistant_message.tool_calls is not None:
                     # Prepare function calls
@@ -1513,12 +1537,23 @@ class Model(ABC):
                 if _compression_manager is not None and await _compression_manager.ashould_compress(
                     messages, tools, model=self, response_format=response_format
                 ):
+                    # Emit compression started event
+                    yield ModelResponse(event=ModelResponseEvent.compression_started.value)
                     await _compression_manager.acompress(messages)
+                    # Emit compression completed event with stats
+                    yield ModelResponse(
+                        event=ModelResponseEvent.compression_completed.value,
+                        compression_stats=_compression_manager.stats.copy(),
+                    )
 
                 # Create assistant message and stream data
                 assistant_message = Message(role=self.assistant_message_role)
                 stream_data = MessageData()
                 model_response = ModelResponse()
+
+                # Emit LLM request started event
+                yield ModelResponse(event=ModelResponseEvent.model_request_started.value)
+
                 if stream_model_response:
                     # Generate response
                     async for model_response in self.aprocess_response_stream(
@@ -1554,6 +1589,19 @@ class Model(ABC):
                 messages.append(assistant_message)
                 assistant_message.log(metrics=True)
 
+                # Emit LLM request completed event with metrics
+                llm_metrics = assistant_message.metrics
+                yield ModelResponse(
+                    event=ModelResponseEvent.model_request_completed.value,
+                    input_tokens=llm_metrics.input_tokens if llm_metrics else None,
+                    output_tokens=llm_metrics.output_tokens if llm_metrics else None,
+                    total_tokens=llm_metrics.total_tokens if llm_metrics else None,
+                    time_to_first_token=llm_metrics.time_to_first_token if llm_metrics else None,
+                    reasoning_tokens=llm_metrics.reasoning_tokens if llm_metrics else None,
+                    cache_read_tokens=llm_metrics.cache_read_tokens if llm_metrics else None,
+                    cache_write_tokens=llm_metrics.cache_write_tokens if llm_metrics else None,
+                )
+
                 # Handle tool calls if present
                 if assistant_message.tool_calls is not None:
                     # Prepare function calls
@@ -1971,8 +2019,6 @@ class Model(ABC):
                     and function_call.function._run_context.session_state is not None
                 ):
                     function_execution_result.updated_session_state = function_call.function._run_context.session_state
-                elif function_call.function._session_state is not None:
-                    function_execution_result.updated_session_state = function_call.function._session_state
         else:
             from agno.tools.function import ToolResult
 
@@ -2532,8 +2578,6 @@ class Model(ABC):
                         and function_call.function._run_context.session_state is not None
                     ):
                         updated_session_state = function_call.function._run_context.session_state
-                    elif function_call.function._session_state is not None:
-                        updated_session_state = function_call.function._session_state
 
             if not (
                 async_function_call_output is not None

agno/models/cohere/chat.py

@@ -115,6 +115,31 @@ class Cohere(Model):
         self.async_client = CohereAsyncClient(**_client_params)
         return self.async_client  # type: ignore
 
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the model to a dictionary.
+
+        Returns:
+            Dict[str, Any]: The dictionary representation of the model.
+        """
+        model_dict = super().to_dict()
+        model_dict.update(
+            {
+                "temperature": self.temperature,
+                "max_tokens": self.max_tokens,
+                "top_k": self.top_k,
+                "top_p": self.top_p,
+                "seed": self.seed,
+                "frequency_penalty": self.frequency_penalty,
+                "presence_penalty": self.presence_penalty,
+                "logprobs": self.logprobs,
+                "strict_tools": self.strict_tools,
+                "add_chat_history": self.add_chat_history,
+            }
+        )
+        cleaned_dict = {k: v for k, v in model_dict.items() if v is not None}
+        return cleaned_dict
+
     def get_request_params(
         self,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,

agno/models/google/gemini.py

@@ -172,6 +172,45 @@ class Gemini(Model):
         self.client = genai.Client(**client_params)
         return self.client
 
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the model to a dictionary.
+
+        Returns:
+            Dict[str, Any]: The dictionary representation of the model.
+        """
+        model_dict = super().to_dict()
+        model_dict.update(
+            {
+                "search": self.search,
+                "grounding": self.grounding,
+                "grounding_dynamic_threshold": self.grounding_dynamic_threshold,
+                "url_context": self.url_context,
+                "vertexai_search": self.vertexai_search,
+                "vertexai_search_datastore": self.vertexai_search_datastore,
+                "file_search_store_names": self.file_search_store_names,
+                "file_search_metadata_filter": self.file_search_metadata_filter,
+                "temperature": self.temperature,
+                "top_p": self.top_p,
+                "top_k": self.top_k,
+                "max_output_tokens": self.max_output_tokens,
+                "stop_sequences": self.stop_sequences,
+                "logprobs": self.logprobs,
+                "presence_penalty": self.presence_penalty,
+                "frequency_penalty": self.frequency_penalty,
+                "seed": self.seed,
+                "response_modalities": self.response_modalities,
+                "thinking_budget": self.thinking_budget,
+                "include_thoughts": self.include_thoughts,
+                "thinking_level": self.thinking_level,
+                "vertexai": self.vertexai,
+                "project_id": self.project_id,
+                "location": self.location,
+            }
+        )
+        cleaned_dict = {k: v for k, v in model_dict.items() if v is not None}
+        return cleaned_dict
+
     def _append_file_search_tool(self, builtin_tools: List[Tool]) -> None:
         """Append Gemini File Search tool to builtin_tools if file search is enabled.
 
@@ -672,7 +711,6 @@ class Gemini(Model):
             compress_tool_results: Whether to compress tool results.
         """
         formatted_messages: List = []
-        file_content: Optional[Union[GeminiFile, Part]] = None
         system_message = None
 
         for message in messages:
@@ -795,14 +833,11 @@ class Gemini(Model):
                     for file in message.files:
                         file_content = self._format_file_for_message(file)
                         if isinstance(file_content, Part):
-                            formatted_messages.append(file_content)
+                            message_parts.append(file_content)
 
             final_message = Content(role=role, parts=message_parts)
             formatted_messages.append(final_message)
 
-            if isinstance(file_content, GeminiFile):
-                formatted_messages.insert(0, file_content)
-
         return formatted_messages, system_message
 
     def _format_audio_for_message(self, audio: Audio) -> Optional[Union[Part, GeminiFile]]:
@@ -936,6 +971,16 @@ class Gemini(Model):
 
         # Case 2: File is a URL
         elif file.url is not None:
+            # Case 2a: GCS URI (gs://) - pass directly to Gemini (supports up to 2GB)
+            if file.url.startswith("gs://") and file.mime_type:
+                return Part.from_uri(file_uri=file.url, mime_type=file.mime_type)
+
+            # Case 2b: HTTPS URL with mime_type - pass directly to Gemini (supports up to 100MB)
+            # This enables pre-signed URLs from S3/Azure and public URLs without downloading
+            if file.url.startswith("https://") and file.mime_type:
+                return Part.from_uri(file_uri=file.url, mime_type=file.mime_type)
+
+            # Case 2c: URL without mime_type - download and detect (existing behavior)
             url_content = file.file_url_content
             if url_content is not None:
                 content, mime_type = url_content

agno/models/litellm/chat.py

@@ -1,3 +1,4 @@
+import copy
 import json
 from dataclasses import dataclass
 from os import getenv
@@ -48,10 +49,18 @@ class LiteLLM(Model):
 
     client: Optional[Any] = None
 
+    # Store the original client to preserve it across copies (e.g., for Router instances)
+    _original_client: Optional[Any] = None
+
     def __post_init__(self):
         """Initialize the model after the dataclass initialization."""
         super().__post_init__()
 
+        # Store the original client if provided (e.g., Router instance)
+        # This ensures the client is preserved when the model is copied for background tasks
+        if self.client is not None and self._original_client is None:
+            self._original_client = self.client
+
         # Set up API key from environment variable if not already set
         if not self.client and not self.api_key:
             self.api_key = getenv("LITELLM_API_KEY")
@@ -70,12 +79,41 @@ class LiteLLM(Model):
         Returns:
             Any: An instance of the LiteLLM client.
         """
+        # First check if we have a current client
         if self.client is not None:
             return self.client
 
+        # Check if we have an original client (e.g., Router) that was preserved
+        # This handles the case where the model was copied for background tasks
+        if self._original_client is not None:
+            self.client = self._original_client
+            return self.client
+
         self.client = litellm
         return self.client
 
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "LiteLLM":
+        """
+        Custom deepcopy to preserve the client (e.g., Router) across copies.
+
+        This is needed because when the model is copied for background tasks
+        (memory, summarization), the client reference needs to be preserved.
+        """
+        # Create a shallow copy first
+        cls = self.__class__
+        result = cls.__new__(cls)
+        memo[id(self)] = result
+
+        # Copy all attributes, but keep the same client reference
+        for k, v in self.__dict__.items():
+            if k in ("client", "_original_client"):
+                # Keep the same client reference (don't deepcopy Router instances)
+                setattr(result, k, v)
+            else:
+                setattr(result, k, copy.deepcopy(v, memo))
+
+        return result
+
     def _format_messages(self, messages: List[Message], compress_tool_results: bool = False) -> List[Dict[str, Any]]:
         """Format messages for LiteLLM API."""
         formatted_messages = []

agno/models/openai/chat.py

@@ -305,6 +305,13 @@ class OpenAIChat(Model):
         cleaned_dict = {k: v for k, v in model_dict.items() if v is not None}
         return cleaned_dict
 
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "OpenAIChat":
+        """
+        Create an OpenAIChat model from a dictionary.
+        """
+        return cls(**data)
+
     def _format_message(self, message: Message, compress_tool_results: bool = False) -> Dict[str, Any]:
         """
         Format a message into the format expected by OpenAI.

agno/models/openrouter/openrouter.py

@@ -2,10 +2,13 @@ from dataclasses import dataclass
 from os import getenv
 from typing import Any, Dict, List, Optional, Type, Union
 
+from openai.types.chat import ChatCompletion, ChatCompletionChunk
 from pydantic import BaseModel
 
 from agno.exceptions import ModelAuthenticationError
+from agno.models.message import Message
 from agno.models.openai.like import OpenAILike
+from agno.models.response import ModelResponse
 from agno.run.agent import RunOutput
 
 
@@ -83,3 +86,46 @@ class OpenRouter(OpenAILike):
             request_params["extra_body"] = extra_body
 
         return request_params
+
+    def _format_message(self, message: Message, compress_tool_results: bool = False) -> Dict[str, Any]:
+        message_dict = super()._format_message(message, compress_tool_results)
+
+        if message.role == "assistant" and message.provider_data:
+            if message.provider_data.get("reasoning_details"):
+                message_dict["reasoning_details"] = message.provider_data["reasoning_details"]
+
+        return message_dict
+
+    def _parse_provider_response(
+        self,
+        response: ChatCompletion,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+    ) -> ModelResponse:
+        model_response = super()._parse_provider_response(response, response_format)
+
+        if response.choices and len(response.choices) > 0:
+            response_message = response.choices[0].message
+            if hasattr(response_message, "reasoning_details") and response_message.reasoning_details:
+                if model_response.provider_data is None:
+                    model_response.provider_data = {}
+                model_response.provider_data["reasoning_details"] = response_message.reasoning_details
+            elif hasattr(response_message, "model_extra"):
+                extra = getattr(response_message, "model_extra", None)
+                if extra and isinstance(extra, dict) and extra.get("reasoning_details"):
+                    if model_response.provider_data is None:
+                        model_response.provider_data = {}
+                    model_response.provider_data["reasoning_details"] = extra["reasoning_details"]
+
+        return model_response
+
+    def _parse_provider_response_delta(self, response_delta: ChatCompletionChunk) -> ModelResponse:
+        model_response = super()._parse_provider_response_delta(response_delta)
+
+        if response_delta.choices and len(response_delta.choices) > 0:
+            choice_delta = response_delta.choices[0].delta
+            if hasattr(choice_delta, "reasoning_details") and choice_delta.reasoning_details:
+                if model_response.provider_data is None:
+                    model_response.provider_data = {}
+                model_response.provider_data["reasoning_details"] = choice_delta.reasoning_details
+
+        return model_response

agno/models/response.py

@@ -16,6 +16,10 @@ class ModelResponseEvent(str, Enum):
     tool_call_started = "ToolCallStarted"
     tool_call_completed = "ToolCallCompleted"
     assistant_response = "AssistantResponse"
+    compression_started = "CompressionStarted"
+    compression_completed = "CompressionCompleted"
+    model_request_started = "ModelRequestStarted"
+    model_request_completed = "ModelRequestCompleted"
 
 
 @dataclass
@@ -124,6 +128,18 @@ class ModelResponse:
 
     updated_session_state: Optional[Dict[str, Any]] = None
 
+    # Compression stats
+    compression_stats: Optional[Dict[str, Any]] = None
+
+    # Model request metrics (for model_request_completed events)
+    input_tokens: Optional[int] = None
+    output_tokens: Optional[int] = None
+    total_tokens: Optional[int] = None
+    time_to_first_token: Optional[float] = None
+    reasoning_tokens: Optional[int] = None
+    cache_read_tokens: Optional[int] = None
+    cache_write_tokens: Optional[int] = None
+
     def to_dict(self) -> Dict[str, Any]:
         """Serialize ModelResponse to dictionary for caching."""
         _dict = asdict(self)