agno 2.2.1__py3-none-any.whl → 2.2.3__py3-none-any.whl

agno/models/base.py

@@ -1,7 +1,11 @@
 import asyncio
 import collections.abc
+import json
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
+from hashlib import md5
+from pathlib import Path
+from time import time
 from types import AsyncGeneratorType, GeneratorType
 from typing import (
     Any,
@@ -29,7 +33,7 @@ from agno.run.agent import CustomEvent, RunContentEvent, RunOutput, RunOutputEve
 from agno.run.team import RunContentEvent as TeamRunContentEvent
 from agno.run.team import TeamRunOutputEvent
 from agno.tools.function import Function, FunctionCall, FunctionExecutionResult, UserInputField
-from agno.utils.log import log_debug, log_error, log_warning
+from agno.utils.log import log_debug, log_error, log_info, log_warning
 from agno.utils.timer import Timer
 from agno.utils.tools import get_function_call_for_tool_call, get_function_call_for_tool_execution
 
@@ -133,6 +137,11 @@ class Model(ABC):
     # The role of the assistant message.
     assistant_message_role: str = "assistant"
 
+    # Cache model responses to avoid redundant API calls during development
+    cache_response: bool = False
+    cache_ttl: Optional[int] = None
+    cache_dir: Optional[str] = None
+
     def __post_init__(self):
         if self.provider is None and self.name is not None:
             self.provider = f"{self.name} ({self.id})"
@@ -145,6 +154,100 @@ class Model(ABC):
     def get_provider(self) -> str:
         return self.provider or self.name or self.__class__.__name__
 
+    def _get_model_cache_key(self, messages: List[Message], stream: bool, **kwargs: Any) -> str:
+        """Generate a cache key based on model messages and core parameters."""
+        message_data = []
+        for msg in messages:
+            msg_dict = {
+                "role": msg.role,
+                "content": msg.content,
+            }
+            message_data.append(msg_dict)
+
+        # Include tools parameter in cache key
+        has_tools = bool(kwargs.get("tools"))
+
+        cache_data = {
+            "model_id": self.id,
+            "messages": message_data,
+            "has_tools": has_tools,
+            "response_format": kwargs.get("response_format"),
+            "stream": stream,
+        }
+
+        cache_str = json.dumps(cache_data, sort_keys=True)
+        return md5(cache_str.encode()).hexdigest()
+
+    def _get_model_cache_file_path(self, cache_key: str) -> Path:
+        """Get the file path for a cache key."""
+        if self.cache_dir:
+            cache_dir = Path(self.cache_dir)
+        else:
+            cache_dir = Path.home() / ".agno" / "cache" / "model_responses"
+
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        return cache_dir / f"{cache_key}.json"
+
+    def _get_cached_model_response(self, cache_key: str) -> Optional[Dict[str, Any]]:
+        """Retrieve a cached response if it exists and is not expired."""
+        cache_file = self._get_model_cache_file_path(cache_key)
+
+        if not cache_file.exists():
+            return None
+
+        try:
+            with open(cache_file, "r") as f:
+                cached_data = json.load(f)
+
+            # Check TTL if set (None means no expiration)
+            if self.cache_ttl is not None:
+                if time() - cached_data["timestamp"] > self.cache_ttl:
+                    return None
+
+            return cached_data
+        except Exception:
+            return None
+
+    def _save_model_response_to_cache(self, cache_key: str, result: ModelResponse, is_streaming: bool = False) -> None:
+        """Save a model response to cache."""
+        try:
+            cache_file = self._get_model_cache_file_path(cache_key)
+
+            cache_data = {
+                "timestamp": int(time()),
+                "is_streaming": is_streaming,
+                "result": result.to_dict(),
+            }
+            with open(cache_file, "w") as f:
+                json.dump(cache_data, f)
+        except Exception:
+            pass
+
+    def _save_streaming_responses_to_cache(self, cache_key: str, responses: List[ModelResponse]) -> None:
+        """Save streaming responses to cache."""
+        cache_file = self._get_model_cache_file_path(cache_key)
+
+        cache_data = {
+            "timestamp": int(time()),
+            "is_streaming": True,
+            "streaming_responses": [r.to_dict() for r in responses],
+        }
+
+        try:
+            with open(cache_file, "w") as f:
+                json.dump(cache_data, f)
+        except Exception:
+            pass
+
+    def _model_response_from_cache(self, cached_data: Dict[str, Any]) -> ModelResponse:
+        """Reconstruct a ModelResponse from cached data."""
+        return ModelResponse.from_dict(cached_data["result"])
+
+    def _streaming_responses_from_cache(self, cached_data: list) -> Iterator[ModelResponse]:
+        """Reconstruct streaming responses from cached data."""
+        for cached_response in cached_data:
+            yield ModelResponse.from_dict(cached_response)
+
     @abstractmethod
     def invoke(self, *args, **kwargs) -> ModelResponse:
         pass
@@ -187,12 +290,21 @@ class Model(ABC):
         """
         pass
 
+    def _format_tools(self, tools: Optional[List[Union[Function, dict]]]) -> List[Dict[str, Any]]:
+        _tool_dicts = []
+        for tool in tools or []:
+            if isinstance(tool, Function):
+                _tool_dicts.append({"type": "function", "function": tool.to_dict()})
+            else:
+                # If a dict is passed, it is a builtin tool
+                _tool_dicts.append(tool)
+        return _tool_dicts
+
     def response(
         self,
         messages: List[Message],
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
-        tools: Optional[List[Dict[str, Any]]] = None,
-        functions: Optional[Dict[str, Function]] = None,
+        tools: Optional[List[Union[Function, dict]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         tool_call_limit: Optional[int] = None,
         run_response: Optional[RunOutput] = None,
@@ -200,8 +312,26 @@ class Model(ABC):
     ) -> ModelResponse:
         """
         Generate a response from the model.
+
+        Args:
+            messages: List of messages to send to the model
+            response_format: Response format to use
+            tools: List of tools to use. This includes the original Function objects and dicts for built-in tools.
+            tool_choice: Tool choice to use
+            tool_call_limit: Tool call limit
+            run_response: Run response to use
+            send_media_to_model: Whether to send media to the model
         """
 
+        # Check cache if enabled
+        if self.cache_response:
+            cache_key = self._get_model_cache_key(messages, stream=False, response_format=response_format, tools=tools)
+            cached_data = self._get_cached_model_response(cache_key)
+
+            if cached_data:
+                log_info("Cache hit for model response")
+                return self._model_response_from_cache(cached_data)
+
         log_debug(f"{self.get_provider()} Response Start", center=True, symbol="-")
         log_debug(f"Model: {self.id}", center=True, symbol="-")
 
@@ -210,6 +340,9 @@ class Model(ABC):
 
         function_call_count = 0
 
+        _tool_dicts = self._format_tools(tools) if tools is not None else []
+        _functions = {tool.name: tool for tool in tools if isinstance(tool, Function)} if tools is not None else {}
+
         while True:
             # Get response from model
             assistant_message = Message(role=self.assistant_message_role)
@@ -218,7 +351,7 @@ class Model(ABC):
                 assistant_message=assistant_message,
                 model_response=model_response,
                 response_format=response_format,
-                tools=tools,
+                tools=_tool_dicts,
                 tool_choice=tool_choice or self._tool_choice,
                 run_response=run_response,
             )
@@ -236,7 +369,7 @@ class Model(ABC):
                     assistant_message=assistant_message,
                     messages=messages,
                     model_response=model_response,
-                    functions=functions,
+                    functions=_functions,
                 )
                 function_call_results: List[Message] = []
 
@@ -334,14 +467,18 @@ class Model(ABC):
             break
 
         log_debug(f"{self.get_provider()} Response End", center=True, symbol="-")
+
+        # Save to cache if enabled
+        if self.cache_response:
+            self._save_model_response_to_cache(cache_key, model_response, is_streaming=False)
+
         return model_response
 
     async def aresponse(
         self,
         messages: List[Message],
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
-        tools: Optional[List[Dict[str, Any]]] = None,
-        functions: Optional[Dict[str, Function]] = None,
+        tools: Optional[List[Union[Function, dict]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         tool_call_limit: Optional[int] = None,
         send_media_to_model: bool = True,
@@ -350,11 +487,23 @@ class Model(ABC):
         Generate an asynchronous response from the model.
         """
 
+        # Check cache if enabled
+        if self.cache_response:
+            cache_key = self._get_model_cache_key(messages, stream=False, response_format=response_format, tools=tools)
+            cached_data = self._get_cached_model_response(cache_key)
+
+            if cached_data:
+                log_info("Cache hit for model response")
+                return self._model_response_from_cache(cached_data)
+
         log_debug(f"{self.get_provider()} Async Response Start", center=True, symbol="-")
         log_debug(f"Model: {self.id}", center=True, symbol="-")
         _log_messages(messages)
         model_response = ModelResponse()
 
+        _tool_dicts = self._format_tools(tools) if tools is not None else []
+        _functions = {tool.name: tool for tool in tools if isinstance(tool, Function)} if tools is not None else {}
+
         function_call_count = 0
 
         while True:
@@ -365,7 +514,7 @@ class Model(ABC):
                 assistant_message=assistant_message,
                 model_response=model_response,
                 response_format=response_format,
-                tools=tools,
+                tools=_tool_dicts,
                 tool_choice=tool_choice or self._tool_choice,
             )
 
@@ -382,7 +531,7 @@ class Model(ABC):
                     assistant_message=assistant_message,
                     messages=messages,
                     model_response=model_response,
-                    functions=functions,
+                    functions=_functions,
                 )
                 function_call_results: List[Message] = []
 
@@ -479,6 +628,11 @@ class Model(ABC):
             break
 
         log_debug(f"{self.get_provider()} Async Response End", center=True, symbol="-")
+
+        # Save to cache if enabled
+        if self.cache_response:
+            self._save_model_response_to_cache(cache_key, model_response, is_streaming=False)
+
         return model_response
 
     def _process_model_response(
@@ -693,8 +847,7 @@ class Model(ABC):
         self,
         messages: List[Message],
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
-        tools: Optional[List[Dict[str, Any]]] = None,
-        functions: Optional[Dict[str, Function]] = None,
+        tools: Optional[List[Union[Function, dict]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         tool_call_limit: Optional[int] = None,
         stream_model_response: bool = True,
@@ -705,10 +858,31 @@ class Model(ABC):
         Generate a streaming response from the model.
         """
 
+        # Check cache if enabled - capture key BEFORE streaming to avoid mismatch
+        cache_key = None
+        if self.cache_response:
+            cache_key = self._get_model_cache_key(messages, stream=True, response_format=response_format, tools=tools)
+            cached_data = self._get_cached_model_response(cache_key)
+
+            if cached_data:
+                log_info("Cache hit for streaming model response")
+                # Yield cached responses
+                for response in self._streaming_responses_from_cache(cached_data["streaming_responses"]):
+                    yield response
+                return
+
+            log_info("Cache miss for streaming model response")
+
+        # Track streaming responses for caching
+        streaming_responses: List[ModelResponse] = []
+
         log_debug(f"{self.get_provider()} Response Stream Start", center=True, symbol="-")
         log_debug(f"Model: {self.id}", center=True, symbol="-")
         _log_messages(messages)
 
+        _tool_dicts = self._format_tools(tools) if tools is not None else []
+        _functions = {tool.name: tool for tool in tools if isinstance(tool, Function)} if tools is not None else {}
+
         function_call_count = 0
 
         while True:
@@ -718,15 +892,18 @@ class Model(ABC):
             model_response = ModelResponse()
             if stream_model_response:
                 # Generate response
-                yield from self.process_response_stream(
+                for response in self.process_response_stream(
                     messages=messages,
                     assistant_message=assistant_message,
                     stream_data=stream_data,
                     response_format=response_format,
-                    tools=tools,
+                    tools=_tool_dicts,
                     tool_choice=tool_choice or self._tool_choice,
                     run_response=run_response,
-                )
+                ):
+                    if self.cache_response and isinstance(response, ModelResponse):
+                        streaming_responses.append(response)
+                    yield response
 
                 # Populate assistant message from stream data
                 if stream_data.response_content:
@@ -750,9 +927,11 @@ class Model(ABC):
                     assistant_message=assistant_message,
                     model_response=model_response,
                     response_format=response_format,
-                    tools=tools,
+                    tools=_tool_dicts,
                     tool_choice=tool_choice or self._tool_choice,
                 )
+                if self.cache_response:
+                    streaming_responses.append(model_response)
                 yield model_response
 
             # Add assistant message to messages
@@ -763,7 +942,7 @@ class Model(ABC):
             if assistant_message.tool_calls is not None:
                 # Prepare function calls
                 function_calls_to_run: List[FunctionCall] = self.get_function_calls_to_run(
-                    assistant_message, messages, functions
+                    assistant_message=assistant_message, messages=messages, functions=_functions
                 )
                 function_call_results: List[Message] = []
 
@@ -774,6 +953,8 @@ class Model(ABC):
                     current_function_call_count=function_call_count,
                     function_call_limit=tool_call_limit,
                 ):
+                    if self.cache_response and isinstance(function_call_response, ModelResponse):
+                        streaming_responses.append(function_call_response)
                     yield function_call_response
 
                 # Add a function call for each successful execution
@@ -792,7 +973,7 @@ class Model(ABC):
                     self.format_function_call_results(messages=messages, function_call_results=function_call_results)
 
                 # Handle function call media
-                if any(msg.images or msg.videos or msg.audio for msg in function_call_results):
+                if any(msg.images or msg.videos or msg.audio or msg.files for msg in function_call_results):
                     self._handle_function_call_media(
                         messages=messages,
                         function_call_results=function_call_results,
@@ -826,6 +1007,10 @@ class Model(ABC):
 
         log_debug(f"{self.get_provider()} Response Stream End", center=True, symbol="-")
 
+        # Save streaming responses to cache if enabled
+        if self.cache_response and cache_key and streaming_responses:
+            self._save_streaming_responses_to_cache(cache_key, streaming_responses)
+
     async def aprocess_response_stream(
         self,
         messages: List[Message],
@@ -861,8 +1046,7 @@ class Model(ABC):
         self,
         messages: List[Message],
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
-        tools: Optional[List[Dict[str, Any]]] = None,
-        functions: Optional[Dict[str, Function]] = None,
+        tools: Optional[List[Union[Function, dict]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         tool_call_limit: Optional[int] = None,
         stream_model_response: bool = True,
@@ -873,10 +1057,31 @@ class Model(ABC):
         Generate an asynchronous streaming response from the model.
         """
 
+        # Check cache if enabled - capture key BEFORE streaming to avoid mismatch
+        cache_key = None
+        if self.cache_response:
+            cache_key = self._get_model_cache_key(messages, stream=True, response_format=response_format, tools=tools)
+            cached_data = self._get_cached_model_response(cache_key)
+
+            if cached_data:
+                log_info("Cache hit for async streaming model response")
+                # Yield cached responses
+                for response in self._streaming_responses_from_cache(cached_data["streaming_responses"]):
+                    yield response
+                return
+
+            log_info("Cache miss for async streaming model response")
+
+        # Track streaming responses for caching
+        streaming_responses: List[ModelResponse] = []
+
         log_debug(f"{self.get_provider()} Async Response Stream Start", center=True, symbol="-")
         log_debug(f"Model: {self.id}", center=True, symbol="-")
         _log_messages(messages)
 
+        _tool_dicts = self._format_tools(tools) if tools is not None else []
+        _functions = {tool.name: tool for tool in tools if isinstance(tool, Function)} if tools is not None else {}
+
         function_call_count = 0
 
         while True:
@@ -891,10 +1096,12 @@ class Model(ABC):
                     assistant_message=assistant_message,
                     stream_data=stream_data,
                     response_format=response_format,
-                    tools=tools,
+                    tools=_tool_dicts,
                     tool_choice=tool_choice or self._tool_choice,
                     run_response=run_response,
                 ):
+                    if self.cache_response and isinstance(model_response, ModelResponse):
+                        streaming_responses.append(model_response)
                     yield model_response
 
                 # Populate assistant message from stream data
@@ -917,10 +1124,12 @@ class Model(ABC):
                     assistant_message=assistant_message,
                     model_response=model_response,
                     response_format=response_format,
-                    tools=tools,
+                    tools=_tool_dicts,
                     tool_choice=tool_choice or self._tool_choice,
                     run_response=run_response,
                 )
+                if self.cache_response:
+                    streaming_responses.append(model_response)
                 yield model_response
 
             # Add assistant message to messages
@@ -931,7 +1140,7 @@ class Model(ABC):
             if assistant_message.tool_calls is not None:
                 # Prepare function calls
                 function_calls_to_run: List[FunctionCall] = self.get_function_calls_to_run(
-                    assistant_message, messages, functions
+                    assistant_message=assistant_message, messages=messages, functions=_functions
                 )
                 function_call_results: List[Message] = []
 
@@ -942,6 +1151,8 @@ class Model(ABC):
                     current_function_call_count=function_call_count,
                     function_call_limit=tool_call_limit,
                 ):
+                    if self.cache_response and isinstance(function_call_response, ModelResponse):
+                        streaming_responses.append(function_call_response)
                     yield function_call_response
 
                 # Add a function call for each successful execution
@@ -960,7 +1171,7 @@ class Model(ABC):
                     self.format_function_call_results(messages=messages, function_call_results=function_call_results)
 
                 # Handle function call media
-                if any(msg.images or msg.videos or msg.audio for msg in function_call_results):
+                if any(msg.images or msg.videos or msg.audio or msg.files for msg in function_call_results):
                     self._handle_function_call_media(
                         messages=messages,
                         function_call_results=function_call_results,
@@ -994,6 +1205,10 @@ class Model(ABC):
 
         log_debug(f"{self.get_provider()} Async Response Stream End", center=True, symbol="-")
 
+        # Save streaming responses to cache if enabled
+        if self.cache_response and cache_key and streaming_responses:
+            self._save_streaming_responses_to_cache(cache_key, streaming_responses)
+
     def _populate_stream_data_and_assistant_message(
         self, stream_data: MessageData, assistant_message: Message, model_response_delta: ModelResponse
     ) -> Iterator[ModelResponse]:
@@ -1147,12 +1362,14 @@ class Model(ABC):
         images = None
         videos = None
         audios = None
+        files = None
 
         if success and function_execution_result:
             # With unified classes, no conversion needed - use directly
             images = function_execution_result.images
             videos = function_execution_result.videos
             audios = function_execution_result.audios
+            files = function_execution_result.files
 
         return Message(
             role=self.tool_message_role,
@@ -1165,6 +1382,7 @@ class Model(ABC):
             images=images,
             videos=videos,
             audio=audios,
+            files=files,
             **kwargs,  # type: ignore
         )
 
@@ -1234,7 +1452,7 @@ class Model(ABC):
                             # Capture output
                             function_call_output += item.content or ""
 
-                        if function_call.function.show_result:
+                        if function_call.function.show_result and item.content is not None:
                             yield ModelResponse(content=item.content)
 
                     if isinstance(item, CustomEvent):
@@ -1245,7 +1463,7 @@ class Model(ABC):
 
                 else:
                     function_call_output += str(item)
-                    if function_call.function.show_result:
+                    if function_call.function.show_result and item is not None:
                         yield ModelResponse(content=str(item))
         else:
             from agno.tools.function import ToolResult
@@ -1267,7 +1485,7 @@ class Model(ABC):
             else:
                 function_call_output = str(function_execution_result.result) if function_execution_result.result else ""
 
-            if function_call.function.show_result:
+            if function_call.function.show_result and function_call_output is not None:
                 yield ModelResponse(content=function_call_output)
 
         # Create and yield function call result
@@ -1416,6 +1634,7 @@ class Model(ABC):
         function_call_timer = Timer()
         function_call_timer.start()
         success: Union[bool, AgentRunException] = False
+        result: FunctionExecutionResult = FunctionExecutionResult(status="failure")
 
         try:
             if (
@@ -1622,7 +1841,7 @@ class Model(ABC):
                                 # Capture output
                                 function_call_output += item.content or ""
 
-                            if function_call.function.show_result:
+                            if function_call.function.show_result and item.content is not None:
                                 await event_queue.put(ModelResponse(content=item.content))
                                 continue
 
@@ -1635,7 +1854,7 @@ class Model(ABC):
                     # Yield custom events emitted by the tool
                     else:
                         function_call_output += str(item)
-                        if function_call.function.show_result:
+                        if function_call.function.show_result and item is not None:
                             await event_queue.put(ModelResponse(content=str(item)))
 
                 # Store the final output for this generator
@@ -1731,7 +1950,7 @@ class Model(ABC):
                                 # Capture output
                                 function_call_output += item.content or ""
 
-                            if function_call.function.show_result:
+                            if function_call.function.show_result and item.content is not None:
                                 yield ModelResponse(content=item.content)
                                 continue
 
@@ -1739,7 +1958,7 @@ class Model(ABC):
                         yield item
                     else:
                         function_call_output += str(item)
-                        if function_call.function.show_result:
+                        if function_call.function.show_result and item is not None:
                             yield ModelResponse(content=str(item))
             else:
                 from agno.tools.function import ToolResult
@@ -1759,7 +1978,7 @@ class Model(ABC):
                 else:
                     function_call_output = str(function_call.result)
 
-                if function_call.function.show_result:
+                if function_call.function.show_result and function_call_output is not None:
                     yield ModelResponse(content=function_call_output)
 
             # Create and yield function call result
@@ -1814,7 +2033,7 @@ class Model(ABC):
             model_response.tool_calls = []
 
         function_calls_to_run: List[FunctionCall] = self.get_function_calls_to_run(
-            assistant_message, messages, functions
+            assistant_message=assistant_message, messages=messages, functions=functions
         )
         return function_calls_to_run
 

agno/models/response.py

@@ -123,6 +123,75 @@ class ModelResponse:
 
     updated_session_state: Optional[Dict[str, Any]] = None
 
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize ModelResponse to dictionary for caching."""
+        _dict = asdict(self)
+
+        # Handle special serialization for audio
+        if self.audio is not None:
+            _dict["audio"] = self.audio.to_dict()
+
+        # Handle lists of media objects
+        if self.images is not None:
+            _dict["images"] = [img.to_dict() for img in self.images]
+        if self.videos is not None:
+            _dict["videos"] = [vid.to_dict() for vid in self.videos]
+        if self.audios is not None:
+            _dict["audios"] = [aud.to_dict() for aud in self.audios]
+        if self.files is not None:
+            _dict["files"] = [f.to_dict() for f in self.files]
+
+        # Handle tool executions
+        if self.tool_executions is not None:
+            _dict["tool_executions"] = [tool_execution.to_dict() for tool_execution in self.tool_executions]
+
+        # Handle response usage which might be a Pydantic BaseModel
+        response_usage = _dict.pop("response_usage", None)
+        if response_usage is not None:
+            try:
+                from pydantic import BaseModel
+
+                if isinstance(response_usage, BaseModel):
+                    _dict["response_usage"] = response_usage.model_dump()
+                else:
+                    _dict["response_usage"] = response_usage
+            except ImportError:
+                _dict["response_usage"] = response_usage
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ModelResponse":
+        """Reconstruct ModelResponse from cached dictionary."""
+        # Reconstruct media objects
+        if data.get("audio"):
+            data["audio"] = Audio(**data["audio"])
+
+        if data.get("images"):
+            data["images"] = [Image(**img) for img in data["images"]]
+        if data.get("videos"):
+            data["videos"] = [Video(**vid) for vid in data["videos"]]
+        if data.get("audios"):
+            data["audios"] = [Audio(**aud) for aud in data["audios"]]
+        if data.get("files"):
+            data["files"] = [File(**f) for f in data["files"]]
+
+        # Reconstruct tool executions
+        if data.get("tool_executions"):
+            data["tool_executions"] = [ToolExecution.from_dict(te) for te in data["tool_executions"]]
+
+        # Reconstruct citations
+        if data.get("citations") and isinstance(data["citations"], dict):
+            data["citations"] = Citations(**data["citations"])
+
+        # Reconstruct response usage (Metrics)
+        if data.get("response_usage") and isinstance(data["response_usage"], dict):
+            from agno.models.metrics import Metrics
+
+            data["response_usage"] = Metrics(**data["response_usage"])
+
+        return cls(**data)
+
 
 class FileType(str, Enum):
     MP4 = "mp4"