agno 2.2.13__py3-none-any.whl → 2.4.3__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:
@@ -96,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.
@@ -107,11 +137,11 @@ class Cerebras(Model):
             return self.client
 
         client_params: Dict[str, Any] = self._get_client_params()
-        if self.http_client:
-            if isinstance(self.http_client, httpx.Client):
-                client_params["http_client"] = self.http_client
-            else:
-                log_debug("http_client is not an instance of httpx.Client.")
+        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
 
@@ -129,12 +159,8 @@ class Cerebras(Model):
         if self.http_client and isinstance(self.http_client, httpx.AsyncClient):
             client_params["http_client"] = self.http_client
         else:
-            if self.http_client:
-                log_debug("The current http_client is not async. A default httpx.AsyncClient will be used instead.")
-            # 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
 
@@ -194,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
 
@@ -215,6 +244,7 @@ class Cerebras(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> ModelResponse:
         """
         Send a chat completion request to the Cerebras API.
@@ -231,7 +261,7 @@ class Cerebras(Model):
         assistant_message.metrics.start_timer()
         provider_response = self.get_client().chat.completions.create(
             model=self.id,
-            messages=[self._format_message(m) for m in messages],  # type: ignore
+            messages=[self._format_message(m, compress_tool_results) for m in messages],  # type: ignore
             **self.get_request_params(response_format=response_format, tools=tools),
         )
         assistant_message.metrics.stop_timer()
@@ -248,6 +278,7 @@ class Cerebras(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> ModelResponse:
         """
         Sends an asynchronous chat completion request to the Cerebras API.
@@ -264,7 +295,7 @@ class Cerebras(Model):
         assistant_message.metrics.start_timer()
         provider_response = await self.get_async_client().chat.completions.create(
             model=self.id,
-            messages=[self._format_message(m) for m in messages],  # type: ignore
+            messages=[self._format_message(m, compress_tool_results) for m in messages],  # type: ignore
             **self.get_request_params(response_format=response_format, tools=tools),
         )
         assistant_message.metrics.stop_timer()
@@ -281,6 +312,7 @@ class Cerebras(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> Iterator[ModelResponse]:
         """
         Send a streaming chat completion request to the Cerebras API.
@@ -298,7 +330,7 @@ class Cerebras(Model):
 
         for chunk in self.get_client().chat.completions.create(
             model=self.id,
-            messages=[self._format_message(m) for m in messages],  # type: ignore
+            messages=[self._format_message(m, compress_tool_results) for m in messages],  # type: ignore
             stream=True,
             **self.get_request_params(response_format=response_format, tools=tools),
         ):
@@ -314,6 +346,7 @@ class Cerebras(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> AsyncIterator[ModelResponse]:
         """
         Sends an asynchronous streaming chat completion request to the Cerebras API.
@@ -331,7 +364,7 @@ class Cerebras(Model):
 
         async_stream = await self.get_async_client().chat.completions.create(
             model=self.id,
-            messages=[self._format_message(m) for m in messages],  # type: ignore
+            messages=[self._format_message(m, compress_tool_results) for m in messages],  # type: ignore
             stream=True,
             **self.get_request_params(response_format=response_format, tools=tools),
         )
@@ -341,20 +374,27 @@ class Cerebras(Model):
 
         assistant_message.metrics.stop_timer()
 
-    def _format_message(self, message: Message) -> Dict[str, Any]:
+    def _format_message(self, message: Message, compress_tool_results: bool = False) -> Dict[str, Any]:
         """
         Format a message into the format expected by the Cerebras API.
 
         Args:
             message (Message): The message to format.
+            compress_tool_results: Whether to compress tool results.
 
         Returns:
             Dict[str, Any]: The formatted message.
         """
+        # Use compressed content for tool messages if compression is active
+        if message.role == "tool":
+            content = message.get_content(use_compressed_content=compress_tool_results)
+        else:
+            content = message.content if message.content is not None else ""
+
         # Basic message content
         message_dict: Dict[str, Any] = {
             "role": message.role,
-            "content": message.content if message.content is not None else "",
+            "content": content,
         }
 
         # Add name if present
@@ -383,7 +423,7 @@ class Cerebras(Model):
             message_dict = {
                 "role": "tool",
                 "tool_call_id": message.tool_call_id,
-                "content": message.content if message.content is not None else "",
+                "content": content,
             }
 
         # Ensure no None values in the message
@@ -462,18 +502,19 @@ class Cerebras(Model):
                 if choice_delta.content:
                     model_response.content = choice_delta.content
 
-                # Add tool calls
+                # Add tool calls - preserve index for proper aggregation in parse_tool_calls
                 if choice_delta.tool_calls:
                     model_response.tool_calls = [
                         {
+                            "index": tool_call.index if hasattr(tool_call, "index") else idx,
                             "id": tool_call.id,
                             "type": tool_call.type,
                             "function": {
-                                "name": tool_call.function.name,
-                                "arguments": tool_call.function.arguments,
+                                "name": tool_call.function.name if tool_call.function else None,
+                                "arguments": tool_call.function.arguments if tool_call.function else None,
                             },
                         }
-                        for tool_call in choice_delta.tool_calls
+                        for idx, tool_call in enumerate(choice_delta.tool_calls)
                     ]
 
         # Add usage metrics
@@ -482,6 +523,61 @@ class Cerebras(Model):
 
         return model_response
 
+    def parse_tool_calls(self, tool_calls_data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """
+        Build complete tool calls from streamed tool call delta data.
+
+        Cerebras streams tool calls incrementally with partial data in each chunk.
+        This method aggregates those chunks by index to produce complete tool calls.
+
+        Args:
+            tool_calls_data: List of tool call deltas from streaming chunks.
+
+        Returns:
+            List[Dict[str, Any]]: List of fully-formed tool call dicts.
+        """
+        tool_calls: List[Dict[str, Any]] = []
+
+        for tool_call_delta in tool_calls_data:
+            # Get the index for this tool call (default to 0 if not present)
+            index = tool_call_delta.get("index", 0)
+
+            # Extend the list if needed
+            while len(tool_calls) <= index:
+                tool_calls.append(
+                    {
+                        "id": None,
+                        "type": None,
+                        "function": {
+                            "name": "",
+                            "arguments": "",
+                        },
+                    }
+                )
+
+            tool_call_entry = tool_calls[index]
+
+            # Update id if present
+            if tool_call_delta.get("id"):
+                tool_call_entry["id"] = tool_call_delta["id"]
+
+            # Update type if present
+            if tool_call_delta.get("type"):
+                tool_call_entry["type"] = tool_call_delta["type"]
+
+            # Update function name and arguments (concatenate for streaming)
+            if tool_call_delta.get("function"):
+                func_delta = tool_call_delta["function"]
+                if func_delta.get("name"):
+                    tool_call_entry["function"]["name"] += func_delta["name"]
+                if func_delta.get("arguments"):
+                    tool_call_entry["function"]["arguments"] += func_delta["arguments"]
+
+        # Filter out any incomplete tool calls (missing id or function name)
+        complete_tool_calls = [tc for tc in tool_calls if tc.get("id") and tc.get("function", {}).get("name")]
+
+        return complete_tool_calls
+
     def _get_metrics(self, response_usage: Union[ChatCompletionResponseUsage, ChatChunkResponseUsage]) -> Metrics:
         """
         Parse the given Cerebras usage into an Agno Metrics object.

agno/models/cerebras/cerebras_openai.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, List, Optional, Type, Union
 
 from pydantic import BaseModel
 
+from agno.exceptions import ModelAuthenticationError
 from agno.models.message import Message
 from agno.models.openai.like import OpenAILike
 from agno.utils.log import log_debug
@@ -20,6 +21,22 @@ class CerebrasOpenAI(OpenAILike):
     base_url: str = "https://api.cerebras.ai/v1"
     api_key: Optional[str] = field(default_factory=lambda: getenv("CEREBRAS_API_KEY", None))
 
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for CEREBRAS_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("CEREBRAS_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="CEREBRAS_API_KEY not set. Please set the CEREBRAS_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()
+
     def get_request_params(
         self,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
@@ -61,7 +78,7 @@ class CerebrasOpenAI(OpenAILike):
             log_debug(f"Calling {self.provider} with request parameters: {request_params}", log_level=2)
         return request_params
 
-    def _format_message(self, message: Message) -> Dict[str, Any]:
+    def _format_message(self, message: Message, compress_tool_results: bool = False) -> Dict[str, Any]:
         """
         Format a message into the format expected by the Cerebras API.
 
@@ -71,6 +88,7 @@ class CerebrasOpenAI(OpenAILike):
         Returns:
             Dict[str, Any]: The formatted message.
         """
+
         # Basic message content
         message_dict: Dict[str, Any] = {
             "role": message.role,
@@ -100,10 +118,11 @@ class CerebrasOpenAI(OpenAILike):
 
         # Handle tool responses
         if message.role == "tool" and message.tool_call_id:
+            content = message.get_content(use_compressed_content=compress_tool_results)
             message_dict = {
                 "role": "tool",
                 "tool_call_id": message.tool_call_id,
-                "content": message.content if message.content is not None else "",
+                "content": content if message.content is not None else "",
             }
 
         # Ensure no None values in the message

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
 
@@ -78,13 +92,54 @@ class Cohere(Model):
         self.api_key = self.api_key or getenv("CO_API_KEY")
 
         if not self.api_key:
-            log_error("CO_API_KEY not set. Please set the CO_API_KEY environment variable.")
+            raise ModelProviderError(
+                message="CO_API_KEY not set. Please set the CO_API_KEY environment variable.",
+                model_name=self.name,
+                model_id=self.id,
+            )
 
         _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
 
+    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,
@@ -155,6 +210,7 @@ class Cohere(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> ModelResponse:
         """
         Invoke a non-streamed chat response from the Cohere API.
@@ -168,7 +224,7 @@ class Cohere(Model):
             assistant_message.metrics.start_timer()
             provider_response = self.get_client().chat(
                 model=self.id,
-                messages=format_messages(messages),  # type: ignore
+                messages=format_messages(messages, compress_tool_results),  # type: ignore
                 **request_kwargs,
             )  # type: ignore
             assistant_message.metrics.stop_timer()
@@ -189,6 +245,7 @@ class Cohere(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> Iterator[ModelResponse]:
         """
         Invoke a streamed chat response from the Cohere API.
@@ -205,7 +262,7 @@ class Cohere(Model):
 
             for response in self.get_client().chat_stream(
                 model=self.id,
-                messages=format_messages(messages),  # type: ignore
+                messages=format_messages(messages, compress_tool_results),  # type: ignore
                 **request_kwargs,
             ):
                 model_response, tool_use = self._parse_provider_response_delta(response, tool_use=tool_use)
@@ -225,6 +282,7 @@ class Cohere(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> ModelResponse:
         """
         Asynchronously invoke a non-streamed chat response from the Cohere API.
@@ -238,7 +296,7 @@ class Cohere(Model):
             assistant_message.metrics.start_timer()
             provider_response = await self.get_async_client().chat(
                 model=self.id,
-                messages=format_messages(messages),  # type: ignore
+                messages=format_messages(messages, compress_tool_results),  # type: ignore
                 **request_kwargs,
             )
             assistant_message.metrics.stop_timer()
@@ -259,6 +317,7 @@ class Cohere(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> AsyncIterator[ModelResponse]:
         """
         Asynchronously invoke a streamed chat response from the Cohere API.
@@ -275,7 +334,7 @@ class Cohere(Model):
 
             async for response in self.get_async_client().chat_stream(
                 model=self.id,
-                messages=format_messages(messages),  # type: ignore
+                messages=format_messages(messages, compress_tool_results),  # type: ignore
                 **request_kwargs,
             ):
                 model_response, tool_use = self._parse_provider_response_delta(response, tool_use=tool_use)

agno/models/cometapi/cometapi.py

@@ -1,9 +1,10 @@
 from dataclasses import dataclass, field
 from os import getenv
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
 
 import httpx
 
+from agno.exceptions import ModelAuthenticationError
 from agno.models.openai.like import OpenAILike
 from agno.utils.log import log_debug
 
@@ -26,6 +27,22 @@ class CometAPI(OpenAILike):
     api_key: Optional[str] = field(default_factory=lambda: getenv("COMETAPI_KEY"))
     base_url: str = "https://api.cometapi.com/v1"
 
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for COMETAPI_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("COMETAPI_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="COMETAPI_KEY not set. Please set the COMETAPI_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()
+
     def get_available_models(self) -> List[str]:
         """
         Fetch available chat models from CometAPI, filtering out non-chat models.

agno/models/dashscope/dashscope.py

@@ -4,7 +4,7 @@ from typing import Any, Dict, List, Optional, Type, Union
 
 from pydantic import BaseModel
 
-from agno.exceptions import ModelProviderError
+from agno.exceptions import ModelAuthenticationError
 from agno.models.openai.like import OpenAILike
 
 
@@ -43,10 +43,9 @@ class DashScope(OpenAILike):
         if not self.api_key:
             self.api_key = getenv("DASHSCOPE_API_KEY")
             if not self.api_key:
-                raise ModelProviderError(
+                raise ModelAuthenticationError(
                     message="DASHSCOPE_API_KEY not set. Please set the DASHSCOPE_API_KEY environment variable.",
                     model_name=self.name,
-                    model_id=self.id,
                 )
 
         # Define base client params

agno/models/deepinfra/deepinfra.py

@@ -1,7 +1,8 @@
 from dataclasses import dataclass, field
 from os import getenv
-from typing import Optional
+from typing import Any, Dict, Optional
 
+from agno.exceptions import ModelAuthenticationError
 from agno.models.openai.like import OpenAILike
 
 
@@ -26,3 +27,19 @@ class DeepInfra(OpenAILike):
     base_url: str = "https://api.deepinfra.com/v1/openai"
 
     supports_native_structured_outputs: bool = False
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for DEEPINFRA_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("DEEPINFRA_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="DEEPINFRA_API_KEY not set. Please set the DEEPINFRA_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()

agno/models/deepseek/deepseek.py

@@ -2,8 +2,11 @@ from dataclasses import dataclass, field
 from os import getenv
 from typing import Any, Dict, Optional
 
-from agno.exceptions import ModelProviderError
+from agno.exceptions import ModelAuthenticationError
+from agno.models.message import Message
 from agno.models.openai.like import OpenAILike
+from agno.utils.log import log_warning
+from agno.utils.openai import _format_file_for_message, audio_to_message, images_to_message
 
 
 @dataclass
@@ -35,10 +38,9 @@ class DeepSeek(OpenAILike):
             self.api_key = getenv("DEEPSEEK_API_KEY")
             if not self.api_key:
                 # Raise error immediately if key is missing
-                raise ModelProviderError(
+                raise ModelAuthenticationError(
                     message="DEEPSEEK_API_KEY not set. Please set the DEEPSEEK_API_KEY environment variable.",
                     model_name=self.name,
-                    model_id=self.id,
                 )
 
         # Define base client params
@@ -59,3 +61,67 @@ class DeepSeek(OpenAILike):
         if self.client_params:
             client_params.update(self.client_params)
         return client_params
+
+    def _format_message(self, message: Message, compress_tool_results: bool = False) -> Dict[str, Any]:
+        """
+        Format a message into the format expected by OpenAI.
+
+        Args:
+            message (Message): The message to format.
+            compress_tool_results: Whether to compress tool results.
+
+        Returns:
+            Dict[str, Any]: The formatted message.
+        """
+        tool_result = message.get_content(use_compressed_content=compress_tool_results)
+
+        message_dict: Dict[str, Any] = {
+            "role": self.role_map[message.role] if self.role_map else self.default_role_map[message.role],
+            "content": tool_result,
+            "name": message.name,
+            "tool_call_id": message.tool_call_id,
+            "tool_calls": message.tool_calls,
+            "reasoning_content": message.reasoning_content,
+        }
+        message_dict = {k: v for k, v in message_dict.items() if v is not None}
+
+        # Ignore non-string message content
+        # because we assume that the images/audio are already added to the message
+        if (message.images is not None and len(message.images) > 0) or (
+            message.audio is not None and len(message.audio) > 0
+        ):
+            # Ignore non-string message content
+            # because we assume that the images/audio are already added to the message
+            if isinstance(message.content, str):
+                message_dict["content"] = [{"type": "text", "text": message.content}]
+                if message.images is not None:
+                    message_dict["content"].extend(images_to_message(images=message.images))
+
+                if message.audio is not None:
+                    message_dict["content"].extend(audio_to_message(audio=message.audio))
+
+        if message.audio_output is not None:
+            message_dict["content"] = ""
+            message_dict["audio"] = {"id": message.audio_output.id}
+
+        if message.videos is not None and len(message.videos) > 0:
+            log_warning("Video input is currently unsupported.")
+
+        if message.files is not None:
+            # Ensure content is a list of parts
+            content = message_dict.get("content")
+            if isinstance(content, str):  # wrap existing text
+                text = content
+                message_dict["content"] = [{"type": "text", "text": text}]
+            elif content is None:
+                message_dict["content"] = []
+            # Insert each file part before text parts
+            for file in message.files:
+                file_part = _format_file_for_message(file)
+                if file_part:
+                    message_dict["content"].insert(0, file_part)
+
+        # Manually add the content field even if it is None
+        if message.content is None:
+            message_dict["content"] = ""
+        return message_dict