agno 2.0.1__py3-none-any.whl → 2.3.0__py3-none-any.whl

agno/models/cerebras/cerebras.py

@@ -12,6 +12,7 @@ from agno.models.message import Message
 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
 
 try:
@@ -45,12 +46,13 @@ class Cerebras(Model):
     supports_json_schema_outputs: bool = True
 
     # Request parameters
-    parallel_tool_calls: bool = False
+    parallel_tool_calls: Optional[bool] = None
     max_completion_tokens: Optional[int] = None
     repetition_penalty: Optional[float] = None
     temperature: Optional[float] = None
     top_p: Optional[float] = None
     top_k: Optional[int] = 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
@@ -63,7 +65,7 @@ class Cerebras(Model):
     max_retries: Optional[int] = None
     default_headers: Optional[Any] = None
     default_query: Optional[Any] = None
-    http_client: Optional[httpx.Client] = None
+    http_client: Optional[Union[httpx.Client, httpx.AsyncClient]] = None
     client_params: Optional[Dict[str, Any]] = None
 
     # Cerebras clients
@@ -102,12 +104,15 @@ class Cerebras(Model):
         Returns:
             CerebrasClient: An instance of the Cerebras client.
         """
-        if self.client:
+        if self.client and not self.client.is_closed():
             return self.client
 
         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 = CerebrasClient(**client_params)
         return self.client
 
@@ -118,17 +123,15 @@ class Cerebras(Model):
         Returns:
             AsyncCerebras: An instance of the asynchronous Cerebras 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 = AsyncCerebrasClient(**client_params)
         return self.async_client
 
@@ -136,6 +139,7 @@ class Cerebras(Model):
         self,
         tools: Optional[List[Dict[str, Any]]] = None,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        **kwargs: Any,
     ) -> Dict[str, Any]:
         """
         Returns keyword arguments for API requests.
@@ -166,7 +170,6 @@ class Cerebras(Model):
                     "type": "function",
                     "function": {
                         "name": tool["function"]["name"],
-                        "strict": True,  # Ensure strict adherence to expected outputs
                         "description": tool["function"]["description"],
                         "parameters": tool["function"]["parameters"],
                     },
@@ -174,7 +177,10 @@ class Cerebras(Model):
                 for tool in tools
             ]
             # Cerebras requires parallel_tool_calls=False for llama-4-scout-17b-16e-instruct
-            request_params["parallel_tool_calls"] = self.parallel_tool_calls
+            if self.id == "llama-4-scout-17b-16e-instruct":
+                request_params["parallel_tool_calls"] = False
+            elif self.parallel_tool_calls is not None:
+                request_params["parallel_tool_calls"] = self.parallel_tool_calls
 
         # Handle response format for structured outputs
         if response_format is not None:
@@ -183,10 +189,10 @@ class Cerebras(Model):
                 and response_format.get("type") == "json_schema"
                 and isinstance(response_format.get("json_schema"), dict)
             ):
-                # Ensure json_schema has strict=True as required by Cerebras API
+                # 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"] = True
+                    schema["strict"] = self.strict_output
 
                 request_params["response_format"] = response_format
 

agno/models/cerebras/cerebras_openai.py

@@ -1,5 +1,5 @@
 import json
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
 from typing import Any, Dict, List, Optional, Type, Union
 
@@ -16,15 +16,16 @@ class CerebrasOpenAI(OpenAILike):
     name: str = "CerebrasOpenAI"
     provider: str = "CerebrasOpenAI"
 
-    parallel_tool_calls: bool = False
+    parallel_tool_calls: Optional[bool] = None
     base_url: str = "https://api.cerebras.ai/v1"
-    api_key: Optional[str] = getenv("CEREBRAS_API_KEY", None)
+    api_key: Optional[str] = field(default_factory=lambda: getenv("CEREBRAS_API_KEY", None))
 
     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.
@@ -44,7 +45,6 @@ class CerebrasOpenAI(OpenAILike):
                     "type": "function",
                     "function": {
                         "name": tool["function"]["name"],
-                        "strict": True,  # Ensure strict adherence to expected outputs
                         "description": tool["function"]["description"],
                         "parameters": tool["function"]["parameters"],
                     },
@@ -52,7 +52,10 @@ class CerebrasOpenAI(OpenAILike):
                 for tool in tools
             ]
             # Cerebras requires parallel_tool_calls=False for llama-4-scout-17b-16e-instruct
-            request_params["parallel_tool_calls"] = self.parallel_tool_calls
+            if self.id == "llama-4-scout-17b-16e-instruct":
+                request_params["parallel_tool_calls"] = False
+            elif self.parallel_tool_calls is not None:
+                request_params["parallel_tool_calls"] = self.parallel_tool_calls
 
         if request_params:
             log_debug(f"Calling {self.provider} with request parameters: {request_params}", log_level=2)

agno/models/cohere/chat.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass
 from os import getenv
 from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Tuple, Type, Union
 
+import httpx
 from pydantic import BaseModel
 
 from agno.exceptions import ModelProviderError
@@ -10,7 +11,8 @@ from agno.models.message import Message
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse
 from agno.run.agent import RunOutput
-from agno.utils.log import log_debug, log_error
+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.cohere import format_messages
 
 try:
@@ -50,6 +52,7 @@ class Cohere(Model):
     # -*- Client parameters
     api_key: Optional[str] = None
     client_params: Optional[Dict[str, Any]] = None
+    http_client: Optional[Union[httpx.Client, httpx.AsyncClient]] = None
     # -*- Provide the Cohere client manually
     client: Optional[CohereClient] = None
     async_client: Optional[CohereAsyncClient] = None
@@ -66,6 +69,17 @@ class Cohere(Model):
 
         _client_params["api_key"] = self.api_key
 
+        if self.http_client:
+            if isinstance(self.http_client, httpx.Client):
+                _client_params["httpx_client"] = self.http_client
+            else:
+                log_warning("http_client is not an instance of httpx.Client. Using default global httpx.Client.")
+                # Use global sync client when user http_client is invalid
+                _client_params["httpx_client"] = get_default_sync_client()
+        else:
+            # Use global sync client when no custom http_client is provided
+            _client_params["httpx_client"] = get_default_sync_client()
+
         self.client = CohereClient(**_client_params)
         return self.client  # type: ignore
 
@@ -82,6 +96,18 @@ class Cohere(Model):
 
         _client_params["api_key"] = self.api_key
 
+        if self.http_client:
+            if isinstance(self.http_client, httpx.AsyncClient):
+                _client_params["httpx_client"] = self.http_client
+            else:
+                log_warning(
+                    "http_client is not an instance of httpx.AsyncClient. Using default global httpx.AsyncClient."
+                )
+                # Use global async client when user http_client is invalid
+                _client_params["httpx_client"] = get_default_async_client()
+        else:
+            # Use global async client when no custom http_client is provided
+            _client_params["httpx_client"] = get_default_async_client()
         self.async_client = CohereAsyncClient(**_client_params)
         return self.async_client  # type: ignore
 

agno/models/cometapi/__init__.py

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

agno/models/cometapi/cometapi.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass, field
+from os import getenv
+from typing import List, Optional
+
+import httpx
+
+from agno.models.openai.like import OpenAILike
+from agno.utils.log import log_debug
+
+
+@dataclass
+class CometAPI(OpenAILike):
+    """
+    The CometAPI class provides access to multiple AI model providers
+    (GPT, Claude, Gemini, DeepSeek, etc.) through OpenAI-compatible endpoints.
+
+    Args:
+        id (str): The id of the CometAPI model to use. Default is "gpt-5-mini".
+        name (str): The name for this model. Defaults to "CometAPI".
+        api_key (str): The API key for CometAPI. Defaults to COMETAPI_KEY environment variable.
+        base_url (str): The base URL for CometAPI. Defaults to "https://api.cometapi.com/v1".
+    """
+
+    name: str = "CometAPI"
+    id: str = "gpt-5-mini"
+    api_key: Optional[str] = field(default_factory=lambda: getenv("COMETAPI_KEY"))
+    base_url: str = "https://api.cometapi.com/v1"
+
+    def get_available_models(self) -> List[str]:
+        """
+        Fetch available chat models from CometAPI, filtering out non-chat models.
+
+        Returns:
+            List of available chat model IDs
+        """
+        if not self.api_key:
+            log_debug("No API key provided, returning empty model list")
+            return []
+
+        try:
+            with httpx.Client() as client:
+                response = client.get(
+                    f"{self.base_url}/models",
+                    headers={"Authorization": f"Bearer {self.api_key}", "Accept": "application/json"},
+                    timeout=30.0,
+                )
+                response.raise_for_status()
+
+                data = response.json()
+                all_models = data.get("data", [])
+
+                log_debug(f"Found {len(all_models)} total models")
+                return sorted(all_models)
+
+        except Exception as e:
+            log_debug(f"Error fetching models from CometAPI: {e}")
+            return []

agno/models/dashscope/dashscope.py

@@ -73,6 +73,7 @@ class DashScope(OpenAILike):
         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]:
         params = super().get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice)
 

agno/models/deepinfra/deepinfra.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
 from typing import Optional
 
@@ -22,7 +22,7 @@ class DeepInfra(OpenAILike):
     name: str = "DeepInfra"
     provider: str = "DeepInfra"
 
-    api_key: Optional[str] = getenv("DEEPINFRA_API_KEY")
+    api_key: Optional[str] = field(default_factory=lambda: getenv("DEEPINFRA_API_KEY"))
     base_url: str = "https://api.deepinfra.com/v1/openai"
 
     supports_native_structured_outputs: bool = False

agno/models/deepseek/deepseek.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
 from typing import Any, Dict, Optional
 
@@ -23,7 +23,7 @@ class DeepSeek(OpenAILike):
     name: str = "DeepSeek"
     provider: str = "DeepSeek"
 
-    api_key: Optional[str] = getenv("DEEPSEEK_API_KEY")
+    api_key: Optional[str] = field(default_factory=lambda: getenv("DEEPSEEK_API_KEY"))
     base_url: str = "https://api.deepseek.com"
 
     # Their support for structured outputs is currently broken

agno/models/fireworks/fireworks.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
 from typing import Optional
 
@@ -22,5 +22,5 @@ class Fireworks(OpenAILike):
     name: str = "Fireworks"
     provider: str = "Fireworks"
 
-    api_key: Optional[str] = getenv("FIREWORKS_API_KEY")
+    api_key: Optional[str] = field(default_factory=lambda: getenv("FIREWORKS_API_KEY"))
     base_url: str = "https://api.fireworks.ai/inference/v1"

agno/models/google/gemini.py

@@ -1,3 +1,4 @@
+import base64
 import json
 import time
 from collections.abc import AsyncIterator
@@ -16,9 +17,8 @@ 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.gemini import convert_schema, format_function_definitions, format_image_for_message
+from agno.utils.gemini import format_function_definitions, format_image_for_message, prepare_response_schema
 from agno.utils.log import log_debug, log_error, log_info, log_warning
-from agno.utils.models.schema_utils import get_response_schema_for_provider
 
 try:
     from google import genai
@@ -27,6 +27,7 @@ try:
     from google.genai.types import (
         Content,
         DynamicRetrievalConfig,
+        FunctionCallingConfigMode,
         GenerateContentConfig,
         GenerateContentResponse,
         GenerateContentResponseUsageMetadata,
@@ -87,7 +88,7 @@ class Gemini(Model):
     presence_penalty: Optional[float] = None
     frequency_penalty: Optional[float] = None
     seed: Optional[int] = None
-    response_modalities: Optional[list[str]] = None  # "Text" and/or "Image"
+    response_modalities: Optional[list[str]] = None  # "TEXT", "IMAGE", and/or "AUDIO"
     speech_config: Optional[dict[str, Any]] = None
     cached_content: Optional[Any] = None
     thinking_budget: Optional[int] = None  # Thinking budget for Gemini 2.5 models
@@ -151,6 +152,7 @@ class Gemini(Model):
         system_message: Optional[str] = None,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
     ) -> Dict[str, Any]:
         """
         Returns the request keyword arguments for the GenerativeModel client.
@@ -191,12 +193,9 @@ class Gemini(Model):
 
         if response_format is not None and isinstance(response_format, type) and issubclass(response_format, BaseModel):
             config["response_mime_type"] = "application/json"  # type: ignore
-            # Convert Pydantic model to JSON schema, then normalize for Gemini, then convert to Gemini schema format
-
-            # Get the normalized schema for Gemini
-            normalized_schema = get_response_schema_for_provider(response_format, "gemini")
-            gemini_schema = convert_schema(normalized_schema)
-            config["response_schema"] = gemini_schema
+            # Convert Pydantic model using our hybrid approach
+            # This will handle complex schemas with nested models, dicts, and circular refs
+            config["response_schema"] = prepare_response_schema(response_format)
 
         # Add thinking configuration
         thinking_config_params = {}
@@ -249,6 +248,18 @@ class Gemini(Model):
         elif tools:
             config["tools"] = [format_function_definitions(tools)]
 
+        if tool_choice is not None:
+            if isinstance(tool_choice, str) and tool_choice.lower() == "auto":
+                config["tool_config"] = {"function_calling_config": {"mode": FunctionCallingConfigMode.AUTO}}
+            elif isinstance(tool_choice, str) and tool_choice.lower() == "none":
+                config["tool_config"] = {"function_calling_config": {"mode": FunctionCallingConfigMode.NONE}}
+            elif isinstance(tool_choice, str) and tool_choice.lower() == "validated":
+                config["tool_config"] = {"function_calling_config": {"mode": FunctionCallingConfigMode.VALIDATED}}
+            elif isinstance(tool_choice, str) and tool_choice.lower() == "any":
+                config["tool_config"] = {"function_calling_config": {"mode": FunctionCallingConfigMode.ANY}}
+            else:
+                config["tool_config"] = {"function_calling_config": {"mode": tool_choice}}
+
         config = {k: v for k, v in config.items() if v is not None}
 
         if config:
@@ -275,7 +286,9 @@ class Gemini(Model):
         Invokes the model with a list of messages and returns the response.
         """
         formatted_messages, system_message = self._format_messages(messages)
-        request_kwargs = self.get_request_params(system_message, response_format=response_format, tools=tools)
+        request_kwargs = self.get_request_params(
+            system_message, response_format=response_format, tools=tools, tool_choice=tool_choice
+        )
         try:
             if run_response and run_response.metrics:
                 run_response.metrics.set_time_to_first_token()
@@ -319,7 +332,9 @@ class Gemini(Model):
         """
         formatted_messages, system_message = self._format_messages(messages)
 
-        request_kwargs = self.get_request_params(system_message, response_format=response_format, tools=tools)
+        request_kwargs = self.get_request_params(
+            system_message, response_format=response_format, tools=tools, tool_choice=tool_choice
+        )
         try:
             if run_response and run_response.metrics:
                 run_response.metrics.set_time_to_first_token()
@@ -360,7 +375,9 @@ class Gemini(Model):
         """
         formatted_messages, system_message = self._format_messages(messages)
 
-        request_kwargs = self.get_request_params(system_message, response_format=response_format, tools=tools)
+        request_kwargs = self.get_request_params(
+            system_message, response_format=response_format, tools=tools, tool_choice=tool_choice
+        )
 
         try:
             if run_response and run_response.metrics:
@@ -404,7 +421,9 @@ class Gemini(Model):
         """
         formatted_messages, system_message = self._format_messages(messages)
 
-        request_kwargs = self.get_request_params(system_message, response_format=response_format, tools=tools)
+        request_kwargs = self.get_request_params(
+            system_message, response_format=response_format, tools=tools, tool_choice=tool_choice
+        )
 
         try:
             if run_response and run_response.metrics:
@@ -462,14 +481,18 @@ class Gemini(Model):
             if role == "model" and message.tool_calls is not None and len(message.tool_calls) > 0:
                 if content is not None:
                     content_str = content if isinstance(content, str) else str(content)
-                    message_parts.append(Part.from_text(text=content_str))
+                    part = Part.from_text(text=content_str)
+                    if message.provider_data and "thought_signature" in message.provider_data:
+                        part.thought_signature = base64.b64decode(message.provider_data["thought_signature"])
+                    message_parts.append(part)
                 for tool_call in message.tool_calls:
-                    message_parts.append(
-                        Part.from_function_call(
-                            name=tool_call["function"]["name"],
-                            args=json.loads(tool_call["function"]["arguments"]),
-                        )
+                    part = Part.from_function_call(
+                        name=tool_call["function"]["name"],
+                        args=json.loads(tool_call["function"]["arguments"]),
                     )
+                    if "thought_signature" in tool_call:
+                        part.thought_signature = base64.b64decode(tool_call["thought_signature"])
+                    message_parts.append(part)
             # Function call results
             elif message.tool_calls is not None and len(message.tool_calls) > 0:
                 for tool_call in message.tool_calls:
@@ -481,7 +504,10 @@ class Gemini(Model):
             # Regular text content
             else:
                 if isinstance(content, str):
-                    message_parts = [Part.from_text(text=content)]
+                    part = Part.from_text(text=content)
+                    if message.provider_data and "thought_signature" in message.provider_data:
+                        part.thought_signature = base64.b64decode(message.provider_data["thought_signature"])
+                    message_parts = [part]
 
             if role == "user" and message.tool_calls is None:
                 # Add images to the message for the model
@@ -816,12 +842,30 @@ class Gemini(Model):
                             else:
                                 model_response.content += content_str
 
+                    # Capture thought signature for text parts
+                    if hasattr(part, "thought_signature") and part.thought_signature:
+                        if model_response.provider_data is None:
+                            model_response.provider_data = {}
+                        model_response.provider_data["thought_signature"] = base64.b64encode(
+                            part.thought_signature
+                        ).decode("ascii")
+
                 if hasattr(part, "inline_data") and part.inline_data is not None:
-                    if model_response.images is None:
-                        model_response.images = []
-                    model_response.images.append(
-                        Image(id=str(uuid4()), content=part.inline_data.data, mime_type=part.inline_data.mime_type)
-                    )
+                    # Handle audio responses (for TTS models)
+                    if part.inline_data.mime_type and part.inline_data.mime_type.startswith("audio/"):
+                        # Store raw bytes data
+                        model_response.audio = Audio(
+                            id=str(uuid4()),
+                            content=part.inline_data.data,
+                            mime_type=part.inline_data.mime_type,
+                        )
+                    # Image responses
+                    else:
+                        if model_response.images is None:
+                            model_response.images = []
+                        model_response.images.append(
+                            Image(id=str(uuid4()), content=part.inline_data.data, mime_type=part.inline_data.mime_type)
+                        )
 
                 # Extract function call if present
                 if hasattr(part, "function_call") and part.function_call is not None:
@@ -837,6 +881,10 @@ class Gemini(Model):
                         },
                     }
 
+                    # Capture thought signature for function calls
+                    if hasattr(part, "thought_signature") and part.thought_signature:
+                        tool_call["thought_signature"] = base64.b64encode(part.thought_signature).decode("ascii")
+
                     model_response.tool_calls.append(tool_call)
 
             citations = Citations()
@@ -928,12 +976,32 @@ class Gemini(Model):
                             else:
                                 model_response.content += text_content
 
+                        # Capture thought signature for text parts
+                        if hasattr(part, "thought_signature") and part.thought_signature:
+                            if model_response.provider_data is None:
+                                model_response.provider_data = {}
+                            model_response.provider_data["thought_signature"] = base64.b64encode(
+                                part.thought_signature
+                            ).decode("ascii")
+
                     if hasattr(part, "inline_data") and part.inline_data is not None:
-                        if model_response.images is None:
-                            model_response.images = []
-                        model_response.images.append(
-                            Image(id=str(uuid4()), content=part.inline_data.data, mime_type=part.inline_data.mime_type)
-                        )
+                        # Audio responses
+                        if part.inline_data.mime_type and part.inline_data.mime_type.startswith("audio/"):
+                            # Store raw bytes audio data
+                            model_response.audio = Audio(
+                                id=str(uuid4()),
+                                content=part.inline_data.data,
+                                mime_type=part.inline_data.mime_type,
+                            )
+                        # Image responses
+                        else:
+                            if model_response.images is None:
+                                model_response.images = []
+                            model_response.images.append(
+                                Image(
+                                    id=str(uuid4()), content=part.inline_data.data, mime_type=part.inline_data.mime_type
+                                )
+                            )
 
                     # Extract function call if present
                     if hasattr(part, "function_call") and part.function_call is not None:
@@ -949,6 +1017,10 @@ class Gemini(Model):
                             },
                         }
 
+                        # Capture thought signature for function calls
+                        if hasattr(part, "thought_signature") and part.thought_signature:
+                            tool_call["thought_signature"] = base64.b64encode(part.thought_signature).decode("ascii")
+
                         model_response.tool_calls.append(tool_call)
 
             if response_delta.candidates[0].grounding_metadata is not None:
@@ -1033,9 +1105,9 @@ class Gemini(Model):
 
         metrics.input_tokens = response_usage.prompt_token_count or 0
         metrics.output_tokens = response_usage.candidates_token_count or 0
-        metrics.total_tokens = metrics.input_tokens + metrics.output_tokens
         if response_usage.thoughts_token_count is not None:
             metrics.output_tokens += response_usage.thoughts_token_count or 0
+        metrics.total_tokens = metrics.input_tokens + metrics.output_tokens
 
         metrics.cache_read_tokens = response_usage.cached_content_token_count or 0