agno 2.3.26__py3-none-any.whl → 2.4.1__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
@@ -1940,6 +1988,7 @@ class Model(ABC):
 
                         if isinstance(item, CustomEvent):
                             function_call_output += str(item)
+                            item.tool_call_id = function_call.call_id
 
                         # For WorkflowCompletedEvent, extract content for final output
                         from agno.run.workflow import WorkflowCompletedEvent
@@ -1971,8 +2020,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
 
@@ -2384,6 +2431,7 @@ class Model(ABC):
 
                         if isinstance(item, CustomEvent):
                             function_call_output += str(item)
+                            item.tool_call_id = function_call.call_id
 
                             # For WorkflowCompletedEvent, extract content for final output
                             from agno.run.workflow import WorkflowCompletedEvent
@@ -2461,8 +2509,12 @@ class Model(ABC):
                                 if async_gen_index in async_generator_outputs:
                                     _, async_function_call_output, error = async_generator_outputs[async_gen_index]
                                     if error:
-                                        log_error(f"Error in async generator: {error}")
-                                        raise error
+                                        # Handle async generator exceptions gracefully like sync generators
+                                        log_error(
+                                            f"Error while iterating async generator for {function_call.function.name}: {error}"
+                                        )
+                                        function_call.error = str(error)
+                                        function_call_success = False
                                 break
                             async_gen_index += 1
 
@@ -2509,6 +2561,10 @@ class Model(ABC):
                                     yield ModelResponse(content=item.content)
                                     continue
 
+                            elif isinstance(item, CustomEvent):
+                                function_call_output += str(item)
+                                item.tool_call_id = function_call.call_id
+
                             # Yield the event itself to bubble it up
                             yield item
                         else:
@@ -2532,8 +2588,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/cerebras/cerebras.py

@@ -97,6 +97,35 @@ class Cerebras(Model):
             client_params.update(self.client_params)
         return client_params
 
+    def _ensure_additional_properties_false(self, schema: Dict[str, Any]) -> None:
+        """
+        Recursively ensure all object types have additionalProperties: false.
+        Cerebras API requires this for JSON schema validation.
+        """
+        if not isinstance(schema, dict):
+            return
+
+        # Set additionalProperties: false for object types
+        if schema.get("type") == "object":
+            schema["additionalProperties"] = False
+
+        # Recursively process nested schemas
+        if "properties" in schema and isinstance(schema["properties"], dict):
+            for prop_schema in schema["properties"].values():
+                self._ensure_additional_properties_false(prop_schema)
+
+        if "items" in schema:
+            self._ensure_additional_properties_false(schema["items"])
+
+        if "$defs" in schema and isinstance(schema["$defs"], dict):
+            for def_schema in schema["$defs"].values():
+                self._ensure_additional_properties_false(def_schema)
+
+        for key in ["allOf", "anyOf", "oneOf"]:
+            if key in schema and isinstance(schema[key], list):
+                for item in schema[key]:
+                    self._ensure_additional_properties_false(item)
+
     def get_client(self) -> CerebrasClient:
         """
         Returns a Cerebras client.
@@ -191,8 +220,11 @@ class Cerebras(Model):
             ):
                 # Ensure json_schema has strict parameter set
                 schema = response_format["json_schema"]
-                if isinstance(schema.get("schema"), dict) and "strict" not in schema:
-                    schema["strict"] = self.strict_output
+                if isinstance(schema.get("schema"), dict):
+                    if "strict" not in schema:
+                        schema["strict"] = self.strict_output
+                    # Cerebras requires additionalProperties: false for all object types
+                    self._ensure_additional_properties_false(schema["schema"])
 
                 request_params["response_format"] = response_format
 

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/n1n/__init__.py

@@ -0,0 +1,3 @@
+from agno.models.n1n.n1n import N1N
+
+__all__ = ["N1N"]

agno/models/n1n/n1n.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass, field
+from os import getenv
+from typing import Any, Dict, Optional
+
+from agno.exceptions import ModelAuthenticationError
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class N1N(OpenAILike):
+    """
+    A class for interacting with n1n.ai models.
+
+    Attributes:
+        id (str): The model id. Defaults to "gpt-4o".
+        name (str): The model name. Defaults to "N1N".
+        provider (str): The provider name. Defaults to "N1N".
+        api_key (Optional[str]): The API key.
+        base_url (str): The base URL. Defaults to "https://api.n1n.ai/v1".
+    """
+
+    id: str = "gpt-4o"
+    name: str = "N1N"
+    provider: str = "N1N"
+
+    api_key: Optional[str] = field(default_factory=lambda: getenv("N1N_API_KEY"))
+    base_url: str = "https://api.n1n.ai/v1"
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        # Fetch API key from env if not already set
+        if not self.api_key:
+            self.api_key = getenv("N1N_API_KEY")
+            if not self.api_key:
+                # Raise error immediately if key is missing
+                raise ModelAuthenticationError(
+                    message="N1N_API_KEY not set. Please set the N1N_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+
+        # Define base client params
+        base_params = {
+            "api_key": self.api_key,
+            "organization": self.organization,
+            "base_url": self.base_url,
+            "timeout": self.timeout,
+            "max_retries": self.max_retries,
+            "default_headers": self.default_headers,
+            "default_query": self.default_query,
+        }
+
+        # Create client_params dict with non-None values
+        client_params = {k: v for k, v in base_params.items() if v is not None}
+
+        # Add additional client params if provided
+        if self.client_params:
+            client_params.update(self.client_params)
+        return client_params

agno/models/openai/chat.py

@@ -43,6 +43,8 @@ class OpenAIChat(Model):
     name: str = "OpenAIChat"
     provider: str = "OpenAI"
     supports_native_structured_outputs: bool = True
+    # If True, only collect metrics on the final streaming chunk (for providers with cumulative token counts)
+    collect_metrics_on_completion: bool = False
 
     # Request parameters
     store: Optional[bool] = None
@@ -305,6 +307,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.
@@ -745,6 +754,21 @@ class OpenAIChat(Model):
                     tool_call_entry["type"] = _tool_call_type
         return tool_calls
 
+    def _should_collect_metrics(self, response: ChatCompletionChunk) -> bool:
+        """
+        Determine if metrics should be collected from the response.
+        """
+        if not response.usage:
+            return False
+
+        if not self.collect_metrics_on_completion:
+            return True
+
+        if not response.choices:
+            return False
+
+        return response.choices[0].finish_reason is not None
+
     def _parse_provider_response(
         self,
         response: ChatCompletion,
@@ -913,7 +937,7 @@ class OpenAIChat(Model):
                         log_warning(f"Error processing audio: {e}")
 
         # Add usage metrics if present
-        if response_delta.usage is not None:
+        if self._should_collect_metrics(response_delta) and response_delta.usage is not None:
             model_response.response_usage = self._get_metrics(response_delta.usage)
 
         return model_response

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/perplexity/perplexity.py

@@ -41,6 +41,8 @@ class Perplexity(OpenAILike):
     id: str = "sonar"
     name: str = "Perplexity"
     provider: str = "Perplexity"
+    # Perplexity returns cumulative token counts in each streaming chunk, so only collect on final chunk
+    collect_metrics_on_completion: bool = True
 
     api_key: Optional[str] = field(default_factory=lambda: getenv("PERPLEXITY_API_KEY"))
     base_url: str = "https://api.perplexity.ai/"