agno 2.0.0rc2__py3-none-any.whl → 2.3.0__py3-none-any.whl

agno/models/openai/responses.py

@@ -8,21 +8,20 @@ from typing_extensions import Literal
 
 from agno.exceptions import ModelProviderError
 from agno.media import File
-from agno.models.base import MessageData, Model
+from agno.models.base import Model
 from agno.models.message import Citations, Message, UrlCitation
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse
 from agno.run.agent import RunOutput
+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
 
 try:
     from openai import APIConnectionError, APIStatusError, AsyncOpenAI, OpenAI, RateLimitError
-    from openai.types.responses.response import Response
-    from openai.types.responses.response_stream_event import ResponseStreamEvent
-    from openai.types.responses.response_usage import ResponseUsage
-except (ImportError, ModuleNotFoundError) as e:
+    from openai.types.responses import Response, ResponseReasoningItem, ResponseStreamEvent, ResponseUsage
+except ImportError as e:
     raise ImportError("`openai` not installed. Please install using `pip install openai -U`") from e
 
 
@@ -47,7 +46,7 @@ class OpenAIResponses(Model):
     parallel_tool_calls: Optional[bool] = None
     reasoning: Optional[Dict[str, Any]] = None
     verbosity: Optional[Literal["low", "medium", "high"]] = None
-    reasoning_effort: Optional[Literal["minimal", "medium", "high"]] = None
+    reasoning_effort: Optional[Literal["minimal", "low", "medium", "high"]] = None
     reasoning_summary: Optional[Literal["auto", "concise", "detailed"]] = None
     store: Optional[bool] = None
     temperature: Optional[float] = None
@@ -55,6 +54,10 @@ class OpenAIResponses(Model):
     truncation: Optional[Literal["auto", "disabled"]] = None
     user: Optional[str] = None
     service_tier: Optional[Literal["auto", "default", "flex", "priority"]] = None
+    strict_output: bool = True  # When True, guarantees schema adherence for structured outputs. When False, attempts to follow schema as a guide but may occasionally deviate
+    extra_headers: Optional[Any] = None
+    extra_query: Optional[Any] = None
+    extra_body: Optional[Any] = None
     request_params: Optional[Dict[str, Any]] = None
 
     # Client parameters
@@ -65,7 +68,7 @@ class OpenAIResponses(Model):
     max_retries: Optional[int] = None
     default_headers: Optional[Dict[str, str]] = None
     default_query: Optional[Dict[str, str]] = None
-    http_client: Optional[httpx.Client] = None
+    http_client: Optional[Union[httpx.Client, httpx.AsyncClient]] = None
     client_params: Optional[Dict[str, Any]] = None
 
     # Parameters affecting built-in tools
@@ -138,7 +141,7 @@ class OpenAIResponses(Model):
 
     def get_client(self) -> OpenAI:
         """
-        Returns an OpenAI client.
+        Returns an OpenAI client. Caches the client to avoid recreating it on every request.
 
         Returns:
             OpenAI: An instance of the OpenAI client.
@@ -149,28 +152,29 @@ class OpenAIResponses(Model):
         client_params: Dict[str, Any] = self._get_client_params()
         if self.http_client is not None:
             client_params["http_client"] = self.http_client
+        else:
+            # Use global sync client when no custom http_client is provided
+            client_params["http_client"] = get_default_sync_client()
 
         self.client = OpenAI(**client_params)
         return self.client
 
     def get_async_client(self) -> AsyncOpenAI:
         """
-        Returns an asynchronous OpenAI client.
+        Returns an asynchronous OpenAI client. Caches the client to avoid recreating it on every request.
 
         Returns:
             AsyncOpenAI: An instance of the asynchronous OpenAI client.
         """
-        if self.async_client:
+        if self.async_client and not self.async_client.is_closed():
             return self.async_client
 
         client_params: Dict[str, Any] = self._get_client_params()
-        if self.http_client:
+        if self.http_client and isinstance(self.http_client, httpx.AsyncClient):
             client_params["http_client"] = self.http_client
         else:
-            # Create a new async HTTP client with custom limits
-            client_params["http_client"] = httpx.AsyncClient(
-                limits=httpx.Limits(max_connections=1000, max_keepalive_connections=100)
-            )
+            # Use global async client when no custom http_client is provided
+            client_params["http_client"] = get_default_async_client()
 
         self.async_client = AsyncOpenAI(**client_params)
         return self.async_client
@@ -201,6 +205,9 @@ class OpenAIResponses(Model):
             "truncation": self.truncation,
             "user": self.user,
             "service_tier": self.service_tier,
+            "extra_headers": self.extra_headers,
+            "extra_query": self.extra_query,
+            "extra_body": self.extra_body,
         }
         # Populate the reasoning parameter
         base_params = self._set_reasoning_request_param(base_params)
@@ -220,7 +227,7 @@ class OpenAIResponses(Model):
                     "type": "json_schema",
                     "name": response_format.__name__,
                     "schema": schema,
-                    "strict": True,
+                    "strict": self.strict_output,
                 }
             else:
                 # JSON mode
@@ -256,23 +263,36 @@ class OpenAIResponses(Model):
 
         # Handle reasoning tools for o3 and o4-mini models
         if self._using_reasoning_model() and messages is not None:
-            request_params["store"] = True
-
-            # Check if the last assistant message has a previous_response_id to continue from
-            previous_response_id = None
-            for msg in reversed(messages):
-                if (
-                    msg.role == "assistant"
-                    and hasattr(msg, "provider_data")
-                    and msg.provider_data
-                    and "response_id" in msg.provider_data
-                ):
-                    previous_response_id = msg.provider_data["response_id"]
-                    log_debug(f"Using previous_response_id: {previous_response_id}")
-                    break
+            if self.store is False:
+                request_params["store"] = False
+
+                # Add encrypted reasoning content to include if not already present
+                include_list = request_params.get("include", []) or []
+                if "reasoning.encrypted_content" not in include_list:
+                    include_list.append("reasoning.encrypted_content")
+                    if request_params.get("include") is None:
+                        request_params["include"] = include_list
+                    elif isinstance(request_params["include"], list):
+                        request_params["include"].extend(include_list)
 
-            if previous_response_id:
-                request_params["previous_response_id"] = previous_response_id
+            else:
+                request_params["store"] = True
+
+                # Check if the last assistant message has a previous_response_id to continue from
+                previous_response_id = None
+                for msg in reversed(messages):
+                    if (
+                        msg.role == "assistant"
+                        and hasattr(msg, "provider_data")
+                        and msg.provider_data
+                        and "response_id" in msg.provider_data
+                    ):
+                        previous_response_id = msg.provider_data["response_id"]
+                        log_debug(f"Using previous_response_id: {previous_response_id}")
+                        break
+
+                if previous_response_id:
+                    request_params["previous_response_id"] = previous_response_id
 
         # Add additional request params if provided
         if self.request_params:
@@ -375,7 +395,7 @@ class OpenAIResponses(Model):
 
         return formatted_tools
 
-    def _format_messages(self, messages: List[Message]) -> List[Dict[str, Any]]:
+    def _format_messages(self, messages: List[Message]) -> List[Union[Dict[str, Any], ResponseReasoningItem]]:
         """
         Format a message into the format expected by OpenAI.
 
@@ -385,13 +405,16 @@ class OpenAIResponses(Model):
         Returns:
             Dict[str, Any]: The formatted message.
         """
-        formatted_messages: List[Dict[str, Any]] = []
+        formatted_messages: List[Union[Dict[str, Any], ResponseReasoningItem]] = []
+
+        messages_to_format = messages
+        previous_response_id: Optional[str] = None
 
-        if self._using_reasoning_model():
+        if self._using_reasoning_model() and self.store is not False:
             # Detect whether we're chaining via previous_response_id. If so, we should NOT
             # re-send prior function_call items; the Responses API already has the state and
             # expects only the corresponding function_call_output items.
-            previous_response_id: Optional[str] = None
+
             for msg in reversed(messages):
                 if (
                     msg.role == "assistant"
@@ -400,6 +423,11 @@ class OpenAIResponses(Model):
                     and "response_id" in msg.provider_data
                 ):
                     previous_response_id = msg.provider_data["response_id"]
+                    msg_index = messages.index(msg)
+
+                    # Include messages after this assistant message
+                    messages_to_format = messages[msg_index + 1 :]
+
                     break
 
         # Build a mapping from function_call id (fc_*) → call_id (call_*) from prior assistant tool_calls
@@ -413,7 +441,7 @@ class OpenAIResponses(Model):
                     if isinstance(fc_id, str) and isinstance(call_id, str):
                         fc_id_to_call_id[fc_id] = call_id
 
-        for message in messages:
+        for message in messages_to_format:
             if message.role in ["user", "system"]:
                 message_dict: Dict[str, Any] = {
                     "role": self.role_map[message.role],
@@ -475,6 +503,12 @@ class OpenAIResponses(Model):
                 content = message.content if message.content is not None else ""
                 formatted_messages.append({"role": self.role_map[message.role], "content": content})
 
+                if self.store is False and hasattr(message, "provider_data") and message.provider_data is not None:
+                    if message.provider_data.get("reasoning_output") is not None:
+                        reasoning_output = ResponseReasoningItem.model_validate(
+                            message.provider_data["reasoning_output"]
+                        )
+                        formatted_messages.append(reasoning_output)
         return formatted_messages
 
     def invoke(
@@ -774,63 +808,6 @@ class OpenAIResponses(Model):
                 _fc_message.tool_call_id = tool_call_ids[_fc_message_index]
                 messages.append(_fc_message)
 
-    def process_response_stream(
-        self,
-        messages: List[Message],
-        assistant_message: Message,
-        stream_data: MessageData,
-        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
-        tools: Optional[List[Dict[str, Any]]] = None,
-        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
-        run_response: Optional[RunOutput] = None,
-    ) -> Iterator[ModelResponse]:
-        """Process the synchronous response stream."""
-        for model_response_delta in self.invoke_stream(
-            messages=messages,
-            assistant_message=assistant_message,
-            tools=tools,
-            response_format=response_format,
-            tool_choice=tool_choice,
-            run_response=run_response,
-        ):
-            yield from self._populate_stream_data_and_assistant_message(
-                stream_data=stream_data,
-                assistant_message=assistant_message,
-                model_response_delta=model_response_delta,
-            )
-
-        # Add final metrics to assistant message
-        self._populate_assistant_message(assistant_message=assistant_message, provider_response=model_response_delta)
-
-    async def aprocess_response_stream(
-        self,
-        messages: List[Message],
-        assistant_message: Message,
-        stream_data: MessageData,
-        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
-        tools: Optional[List[Dict[str, Any]]] = None,
-        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
-        run_response: Optional[RunOutput] = None,
-    ) -> AsyncIterator[ModelResponse]:
-        """Process the asynchronous response stream."""
-        async for model_response_delta in self.ainvoke_stream(
-            messages=messages,
-            assistant_message=assistant_message,
-            tools=tools,
-            response_format=response_format,
-            tool_choice=tool_choice,
-            run_response=run_response,
-        ):
-            for model_response in self._populate_stream_data_and_assistant_message(
-                stream_data=stream_data,
-                assistant_message=assistant_message,
-                model_response_delta=model_response_delta,
-            ):
-                yield model_response
-
-        # Add final metrics to assistant message
-        self._populate_assistant_message(assistant_message=assistant_message, provider_response=model_response_delta)
-
     def _parse_provider_response(self, response: Response, **kwargs) -> ModelResponse:
         """
         Parse the OpenAI response into a ModelResponse.
@@ -858,7 +835,7 @@ class OpenAIResponses(Model):
 
         # Add role
         model_response.role = "assistant"
-        reasoning_summary: str = ""
+        reasoning_summary: Optional[str] = None
 
         for output in response.output:
             # Add content
@@ -898,8 +875,14 @@ class OpenAIResponses(Model):
                 model_response.extra = model_response.extra or {}
                 model_response.extra.setdefault("tool_call_ids", []).append(output.call_id)
 
-            # Add reasoning summary
+            # Handle reasoning output items
             elif output.type == "reasoning":
+                # Save encrypted reasoning content for ZDR mode
+                if self.store is False:
+                    if model_response.provider_data is None:
+                        model_response.provider_data = {}
+                    model_response.provider_data["reasoning_output"] = output.model_dump(exclude_none=True)
+
                 if reasoning_summaries := getattr(output, "summary", None):
                     for summary in reasoning_summaries:
                         if isinstance(summary, dict):
@@ -1009,19 +992,27 @@ class OpenAIResponses(Model):
         elif stream_event.type == "response.completed":
             model_response = ModelResponse()
 
-            # Add reasoning summary
-            if self.reasoning_summary is not None:
+            # Handle reasoning output items
+            if self.reasoning_summary is not None or self.store is False:
                 summary_text: str = ""
                 for out in getattr(stream_event.response, "output", []) or []:
                     if getattr(out, "type", None) == "reasoning":
-                        summaries = getattr(out, "summary", None)
-                        if summaries:
-                            for s in summaries:
-                                text_val = s.get("text") if isinstance(s, dict) else getattr(s, "text", None)
-                                if text_val:
-                                    if summary_text:
-                                        summary_text += "\n\n"
-                                    summary_text += text_val
+                        # In ZDR mode (store=False), store reasoning data for next request
+                        if self.store is False and hasattr(out, "encrypted_content"):
+                            if model_response.provider_data is None:
+                                model_response.provider_data = {}
+                            # Store the complete output item
+                            model_response.provider_data["reasoning_output"] = out.model_dump(exclude_none=True)
+                        if self.reasoning_summary is not None:
+                            summaries = getattr(out, "summary", None)
+                            if summaries:
+                                for s in summaries:
+                                    text_val = s.get("text") if isinstance(s, dict) else getattr(s, "text", None)
+                                    if text_val:
+                                        if summary_text:
+                                            summary_text += "\n\n"
+                                        summary_text += text_val
+
                 if summary_text:
                     model_response.reasoning_content = summary_text
 
@@ -1047,4 +1038,10 @@ class OpenAIResponses(Model):
         metrics.output_tokens = response_usage.output_tokens or 0
         metrics.total_tokens = response_usage.total_tokens or 0
 
+        if input_tokens_details := response_usage.input_tokens_details:
+            metrics.cache_read_tokens = input_tokens_details.cached_tokens
+
+        if output_tokens_details := response_usage.output_tokens_details:
+            metrics.reasoning_tokens = output_tokens_details.reasoning_tokens
+
         return metrics

agno/models/openrouter/openrouter.py

@@ -1,8 +1,11 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
-from typing import Optional
+from typing import Any, Dict, List, Optional, Type, Union
+
+from pydantic import BaseModel
 
 from agno.models.openai.like import OpenAILike
+from agno.run.agent import RunOutput
 
 
 @dataclass
@@ -17,12 +20,47 @@ class OpenRouter(OpenAILike):
         api_key (Optional[str]): The API key.
         base_url (str): The base URL. Defaults to "https://openrouter.ai/api/v1".
         max_tokens (int): The maximum number of tokens. Defaults to 1024.
+        fallback_models (Optional[List[str]]): List of fallback model IDs to use if the primary model
+            fails due to rate limits, timeouts, or unavailability. OpenRouter will automatically try
+            these models in order. Example: ["anthropic/claude-sonnet-4", "deepseek/deepseek-r1"]
     """
 
     id: str = "gpt-4o"
     name: str = "OpenRouter"
     provider: str = "OpenRouter"
 
-    api_key: Optional[str] = getenv("OPENROUTER_API_KEY")
+    api_key: Optional[str] = field(default_factory=lambda: getenv("OPENROUTER_API_KEY"))
     base_url: str = "https://openrouter.ai/api/v1"
     max_tokens: int = 1024
+    models: Optional[List[str]] = None  # Dynamic model routing https://openrouter.ai/docs/features/model-routing
+
+    def get_request_params(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        run_response: Optional[RunOutput] = None,
+    ) -> Dict[str, Any]:
+        """
+        Returns keyword arguments for API requests, including fallback models configuration.
+
+        Returns:
+            Dict[str, Any]: A dictionary of keyword arguments for API requests.
+        """
+        # Get base request params from parent class
+        request_params = super().get_request_params(
+            response_format=response_format, tools=tools, tool_choice=tool_choice, run_response=run_response
+        )
+
+        # Add fallback models to extra_body if specified
+        if self.models:
+            # Get existing extra_body or create new dict
+            extra_body = request_params.get("extra_body") or {}
+
+            # Merge fallback models into extra_body
+            extra_body["models"] = self.models
+
+            # Update request params
+            request_params["extra_body"] = extra_body
+
+        return request_params

agno/models/perplexity/perplexity.py

@@ -1,6 +1,6 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
-from typing import Any, Dict, List, Optional, Type, Union
+from typing import Any, Dict, Optional, Type, Union
 
 from pydantic import BaseModel
 
@@ -42,7 +42,7 @@ class Perplexity(OpenAILike):
     name: str = "Perplexity"
     provider: str = "Perplexity"
 
-    api_key: Optional[str] = getenv("PERPLEXITY_API_KEY")
+    api_key: Optional[str] = field(default_factory=lambda: getenv("PERPLEXITY_API_KEY"))
     base_url: str = "https://api.perplexity.ai/"
     max_tokens: int = 1024
     top_k: Optional[float] = None
@@ -53,8 +53,7 @@ class Perplexity(OpenAILike):
     def get_request_params(
         self,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
-        tools: Optional[List[Dict[str, Any]]] = None,
-        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        **kwargs: Any,
     ) -> Dict[str, Any]:
         """
         Returns keyword arguments for API requests.

agno/models/portkey/portkey.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
 from typing import Any, Dict, Optional, cast
 
@@ -30,8 +30,8 @@ class Portkey(OpenAILike):
     name: str = "Portkey"
     provider: str = "Portkey"
 
-    portkey_api_key: Optional[str] = getenv("PORTKEY_API_KEY")
-    virtual_key: Optional[str] = getenv("PORTKEY_VIRTUAL_KEY")
+    portkey_api_key: Optional[str] = field(default_factory=lambda: getenv("PORTKEY_API_KEY"))
+    virtual_key: Optional[str] = field(default_factory=lambda: getenv("PORTKEY_VIRTUAL_KEY"))
     config: Optional[Dict[str, Any]] = None
     base_url: str = PORTKEY_GATEWAY_URL
 

agno/models/requesty/__init__.py

@@ -0,0 +1,5 @@
+from agno.models.requesty.requesty import Requesty
+
+__all__ = [
+    "Requesty",
+]

agno/models/requesty/requesty.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass, field
+from os import getenv
+from typing import Any, Dict, List, Optional, Type, Union
+
+from pydantic import BaseModel
+
+from agno.models.openai.like import OpenAILike
+from agno.run.agent import RunOutput
+from agno.run.team import TeamRunOutput
+
+
+@dataclass
+class Requesty(OpenAILike):
+    """
+    A class for using models hosted on Requesty.
+
+    Attributes:
+        id (str): The model id. Defaults to "openai/gpt-4.1".
+        provider (str): The provider name. Defaults to "Requesty".
+        api_key (Optional[str]): The API key.
+        base_url (str): The base URL. Defaults to "https://router.requesty.ai/v1".
+        max_tokens (int): The maximum number of tokens. Defaults to 1024.
+    """
+
+    id: str = "openai/gpt-4.1"
+    name: str = "Requesty"
+    provider: str = "Requesty"
+
+    api_key: Optional[str] = field(default_factory=lambda: getenv("REQUESTY_API_KEY"))
+    base_url: str = "https://router.requesty.ai/v1"
+    max_tokens: int = 1024
+
+    def get_request_params(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        run_response: Optional[Union[RunOutput, TeamRunOutput]] = None,
+    ) -> Dict[str, Any]:
+        params = super().get_request_params(
+            response_format=response_format, tools=tools, tool_choice=tool_choice, run_response=run_response
+        )
+
+        if "extra_body" not in params:
+            params["extra_body"] = {}
+        params["extra_body"]["requesty"] = {}
+        if run_response and run_response.user_id:
+            params["extra_body"]["requesty"]["user_id"] = run_response.user_id
+        if run_response and run_response.session_id:
+            params["extra_body"]["requesty"]["trace_id"] = run_response.session_id
+
+        return params

agno/models/response.py

@@ -3,7 +3,7 @@ from enum import Enum
 from time import time
 from typing import Any, Dict, List, Optional
 
-from agno.media import AudioArtifact, AudioResponse, ImageArtifact, VideoArtifact
+from agno.media import Audio, File, Image, Video
 from agno.models.message import Citations
 from agno.models.metrics import Metrics
 from agno.tools.function import UserInputField
@@ -29,11 +29,15 @@ class ToolExecution:
     result: Optional[str] = None
     metrics: Optional[Metrics] = None
 
+    # In the case where a tool call creates a run of an agent/team/workflow
+    child_run_id: Optional[str] = None
+
     # If True, the agent will stop executing after this tool call.
     stop_after_tool_call: bool = False
 
     created_at: int = int(time())
 
+    # User control flow requirements
     requires_confirmation: Optional[bool] = None
     confirmed: Optional[bool] = None
     confirmation_note: Optional[str] = None
@@ -66,6 +70,7 @@ class ToolExecution:
             tool_args=data.get("tool_args"),
             tool_call_error=data.get("tool_call_error"),
             result=data.get("result"),
+            child_run_id=data.get("child_run_id"),
             stop_after_tool_call=data.get("stop_after_tool_call", False),
             requires_confirmation=data.get("requires_confirmation"),
             confirmed=data.get("confirmed"),
@@ -87,12 +92,13 @@ class ModelResponse:
 
     content: Optional[Any] = None
     parsed: Optional[Any] = None
-    audio: Optional[AudioResponse] = None
+    audio: Optional[Audio] = None
 
     # Unified media fields for LLM-generated and tool-generated media artifacts
-    images: Optional[List[ImageArtifact]] = None
-    videos: Optional[List[VideoArtifact]] = None
-    audios: Optional[List[AudioArtifact]] = None
+    images: Optional[List[Image]] = None
+    videos: Optional[List[Video]] = None
+    audios: Optional[List[Audio]] = None
+    files: Optional[List[File]] = None
 
     # Model tool calls
     tool_calls: List[Dict[str, Any]] = field(default_factory=list)
@@ -117,8 +123,78 @@ 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"
     GIF = "gif"
     MP3 = "mp3"
+    WAV = "wav"