agno 2.2.13__py3-none-any.whl → 2.4.3__py3-none-any.whl

agno/models/litellm/litellm_openai.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
 
 
@@ -23,3 +24,19 @@ class LiteLLMOpenAI(OpenAILike):
 
     api_key: Optional[str] = field(default_factory=lambda: getenv("LITELLM_API_KEY"))
     base_url: str = "http://0.0.0.0:4000"
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for LITELLM_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("LITELLM_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="LITELLM_API_KEY not set. Please set the LITELLM_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()

agno/models/message.py

@@ -42,6 +42,9 @@ class Citations(BaseModel):
     # Raw citations from the model
     raw: Optional[Any] = None
 
+    # Search queries used to retrieve the citations
+    search_queries: Optional[List[str]] = None
+
     # URLs of the citations.
     urls: Optional[List[UrlCitation]] = None
 
@@ -59,6 +62,9 @@ class Message(BaseModel):
     role: str
     # The contents of the message.
     content: Optional[Union[List[Any], str]] = None
+    # Compressed content of the message
+    compressed_content: Optional[str] = None
+
     # An optional name for the participant.
     # Provides the model information to differentiate between participants of the same role.
     name: Optional[str] = None
@@ -109,6 +115,8 @@ class Message(BaseModel):
     references: Optional[MessageReferences] = None
     # The Unix timestamp the message was created.
     created_at: int = Field(default_factory=lambda: int(time()))
+    # When True, the message will be sent to the Model but not persisted afterwards.
+    temporary: bool = False
 
     model_config = ConfigDict(extra="allow", populate_by_name=True, arbitrary_types_allowed=True)
 
@@ -123,6 +131,12 @@ class Message(BaseModel):
                 return json.dumps(self.content)
         return ""
 
+    def get_content(self, use_compressed_content: bool = False) -> Optional[Union[List[Any], str]]:
+        """Return tool result content to send to API"""
+        if use_compressed_content and self.compressed_content is not None:
+            return self.compressed_content
+        return self.content
+
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "Message":
         # Handle image reconstruction properly
@@ -266,6 +280,7 @@ class Message(BaseModel):
             "content": self.content,
             "reasoning_content": self.reasoning_content,
             "from_history": self.from_history,
+            "compressed_content": self.compressed_content,
             "stop_after_tool_call": self.stop_after_tool_call,
             "role": self.role,
             "name": self.name,
@@ -315,13 +330,14 @@ class Message(BaseModel):
             "created_at": self.created_at,
         }
 
-    def log(self, metrics: bool = True, level: Optional[str] = None):
+    def log(self, metrics: bool = True, level: Optional[str] = None, use_compressed_content: bool = False):
         """Log the message to the console
 
         Args:
             metrics (bool): Whether to log the metrics.
             level (str): The level to log the message at. One of debug, info, warning, or error.
                 Defaults to debug.
+            use_compressed_content (bool): Whether to use compressed content.
         """
         _logger = log_debug
         if level == "info":
@@ -348,10 +364,13 @@ class Message(BaseModel):
         if self.reasoning_content:
             _logger(f"<reasoning>\n{self.reasoning_content}\n</reasoning>")
         if self.content:
-            if isinstance(self.content, str) or isinstance(self.content, list):
-                _logger(self.content)
-            elif isinstance(self.content, dict):
-                _logger(json.dumps(self.content, indent=2))
+            if use_compressed_content and self.compressed_content:
+                _logger("Compressed content:\n" + self.compressed_content)
+            else:
+                if isinstance(self.content, str) or isinstance(self.content, list):
+                    _logger(self.content)
+                elif isinstance(self.content, dict):
+                    _logger(json.dumps(self.content, indent=2))
         if self.tool_calls:
             tool_calls_list = ["Tool Calls:"]
             for tool_call in self.tool_calls:

agno/models/meta/llama.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
 from agno.utils.models.llama import format_message
 
@@ -108,7 +109,12 @@ class Llama(Model):
             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.")
+                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["http_client"] = get_default_sync_client()
+        else:
+            # Use global sync client when no custom http_client is provided
+            client_params["http_client"] = get_default_sync_client()
         self.client = LlamaAPIClient(**client_params)
         return self.client
 
@@ -123,15 +129,20 @@ class Llama(Model):
             return self.async_client
 
         client_params: Dict[str, Any] = self._get_client_params()
-        if self.http_client and isinstance(self.http_client, httpx.AsyncClient):
-            client_params["http_client"] = self.http_client
+        if self.http_client:
+            if isinstance(self.http_client, httpx.AsyncClient):
+                client_params["http_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["http_client"] = get_default_async_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()
+
+        # Create and cache the client
         self.async_client = AsyncLlamaAPIClient(**client_params)
         return self.async_client
 
@@ -206,6 +217,7 @@ class Llama(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 Llama API.
@@ -214,7 +226,10 @@ class Llama(Model):
 
         provider_response = self.get_client().chat.completions.create(
             model=self.id,
-            messages=[format_message(m, tool_calls=bool(tools)) for m in messages],  # type: ignore
+            messages=[
+                format_message(m, tool_calls=bool(tools), compress_tool_results=compress_tool_results)  # type: ignore
+                for m in messages
+            ],
             **self.get_request_params(tools=tools, response_format=response_format),
         )
 
@@ -231,6 +246,7 @@ class Llama(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 Llama API.
@@ -242,7 +258,10 @@ class Llama(Model):
 
         provider_response = await self.get_async_client().chat.completions.create(
             model=self.id,
-            messages=[format_message(m, tool_calls=bool(tools)) for m in messages],  # type: ignore
+            messages=[
+                format_message(m, tool_calls=bool(tools), compress_tool_results=compress_tool_results)  # type: ignore
+                for m in messages
+            ],
             **self.get_request_params(tools=tools, response_format=response_format),
         )
 
@@ -259,6 +278,7 @@ class Llama(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 Llama API.
@@ -271,7 +291,10 @@ class Llama(Model):
 
             for chunk in self.get_client().chat.completions.create(
                 model=self.id,
-                messages=[format_message(m, tool_calls=bool(tools)) for m in messages],  # type: ignore
+                messages=[
+                    format_message(m, tool_calls=bool(tools), compress_tool_results=compress_tool_results)  # type: ignore
+                    for m in messages
+                ],
                 stream=True,
                 **self.get_request_params(tools=tools, response_format=response_format),
             ):
@@ -291,6 +314,7 @@ class Llama(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 Llama API.
@@ -303,7 +327,10 @@ class Llama(Model):
         try:
             async for chunk in await self.get_async_client().chat.completions.create(
                 model=self.id,
-                messages=[format_message(m, tool_calls=bool(tools)) for m in messages],  # type: ignore
+                messages=[
+                    format_message(m, tool_calls=bool(tools), compress_tool_results=compress_tool_results)  # type: ignore
+                    for m in messages
+                ],
                 stream=True,
                 **self.get_request_params(tools=tools, response_format=response_format),
             ):

agno/models/meta/llama_openai.py

@@ -1,14 +1,13 @@
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from os import getenv
 from typing import Any, Dict, Optional
 
-import httpx
-
 try:
     from openai import AsyncOpenAI as AsyncOpenAIClient
 except ImportError:
     raise ImportError("`openai` not installed. Please install using `pip install openai`")
 
+from agno.exceptions import ModelAuthenticationError
 from agno.models.meta.llama import Message
 from agno.models.openai.like import OpenAILike
 from agno.utils.models.llama import format_message
@@ -31,7 +30,7 @@ class LlamaOpenAI(OpenAILike):
     name: str = "LlamaOpenAI"
     provider: str = "LlamaOpenAI"
 
-    api_key: Optional[str] = field(default_factory=lambda: getenv("LLAMA_API_KEY"))
+    api_key: Optional[str] = None
     base_url: Optional[str] = "https://api.llama.com/compat/v1/"
 
     # Request parameters
@@ -48,6 +47,25 @@ class LlamaOpenAI(OpenAILike):
     supports_native_structured_outputs: bool = False
     supports_json_schema_outputs: bool = True
 
+    # Cached async client
+    openai_async_client: Optional[AsyncOpenAIClient] = None
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for LLAMA_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("LLAMA_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="LLAMA_API_KEY not set. Please set the LLAMA_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()
+
     def _format_message(self, message: Message) -> Dict[str, Any]:
         """
         Format a message into the format expected by Llama API.
@@ -59,20 +77,3 @@ class LlamaOpenAI(OpenAILike):
             Dict[str, Any]: The formatted message.
         """
         return format_message(message, openai_like=True)
-
-    def get_async_client(self):
-        """Override to provide custom httpx client that properly handles redirects"""
-        if self.async_client and not self.async_client.is_closed():
-            return self.async_client
-
-        client_params = self._get_client_params()
-
-        # Llama gives a 307 redirect error, so we need to set up a custom client to allow redirects
-        client_params["http_client"] = httpx.AsyncClient(
-            limits=httpx.Limits(max_connections=1000, max_keepalive_connections=100),
-            follow_redirects=True,
-            timeout=httpx.Timeout(30.0),
-        )
-
-        self.async_client = AsyncOpenAIClient(**client_params)
-        return self.async_client

agno/models/metrics.py

@@ -13,6 +13,10 @@ class Metrics:
     output_tokens: int = 0
     total_tokens: int = 0
 
+    # Cost of the run
+    # Currently only supported by some providers
+    cost: Optional[float] = None
+
     # Audio token usage
     audio_input_tokens: int = 0
     audio_output_tokens: int = 0
@@ -43,6 +47,7 @@ class Metrics:
         metrics_dict = asdict(self)
         # Remove the timer util if present
         metrics_dict.pop("timer", None)
+        # Remove any None, 0, or empty dict values
         metrics_dict = {
             k: v
             for k, v in metrics_dict.items()
@@ -65,6 +70,13 @@ class Metrics:
             reasoning_tokens=self.reasoning_tokens + other.reasoning_tokens,
         )
 
+        if self.cost is not None and other.cost is not None:
+            result.cost = self.cost + other.cost
+        elif self.cost is not None:
+            result.cost = self.cost
+        elif other.cost is not None:
+            result.cost = other.cost
+
         # Handle provider_metrics
         if self.provider_metrics or other.provider_metrics:
             result.provider_metrics = {}

agno/models/mistral/mistral.py

@@ -174,11 +174,12 @@ class MistralChat(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 Mistral model.
         """
-        mistral_messages = format_messages(messages)
+        mistral_messages = format_messages(messages, compress_tool_results)
         try:
             response: Union[ChatCompletionResponse, ParsedChatCompletionResponse]
             if (
@@ -229,11 +230,12 @@ class MistralChat(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]:
         """
         Stream the response from the Mistral model.
         """
-        mistral_messages = format_messages(messages)
+        mistral_messages = format_messages(messages, compress_tool_results)
 
         if run_response and run_response.metrics:
             run_response.metrics.set_time_to_first_token()
@@ -265,11 +267,12 @@ class MistralChat(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 an asynchronous chat completion request to the Mistral API.
         """
-        mistral_messages = format_messages(messages)
+        mistral_messages = format_messages(messages, compress_tool_results)
         try:
             response: Union[ChatCompletionResponse, ParsedChatCompletionResponse]
             if (
@@ -316,11 +319,12 @@ class MistralChat(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]:
         """
         Stream an asynchronous response from the Mistral API.
         """
-        mistral_messages = format_messages(messages)
+        mistral_messages = format_messages(messages, compress_tool_results)
         try:
             if run_response and run_response.metrics:
                 run_response.metrics.set_time_to_first_token()

agno/models/n1n/__init__.py

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

agno/models/n1n/n1n.py

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

agno/models/nebius/nebius.py

@@ -2,36 +2,35 @@ 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.openai.like import OpenAILike
 
 
 @dataclass
 class Nebius(OpenAILike):
     """
-    A class for interacting with Nebius AI Studio models.
+    A class for interacting with Nebius Token Factory models.
 
     Attributes:
         id (str): The model id. Defaults to "Qwen/Qwen3-235B-A22B"".
         name (str): The model name. Defaults to "Nebius".
         provider (str): The provider name. Defaults to "Nebius".
         api_key (Optional[str]): The API key.
-        base_url (str): The base URL. Defaults to "https://api.studio.nebius.com/v1".
+        base_url (str): The base URL. Defaults to "https://api.tokenfactory.nebius.com/v1".
     """
 
-    id: str = "Qwen/Qwen3-4B-fast"  # Default model for chat
+    id: str = "openai/gpt-oss-20b"  # Default model for chat
     name: str = "Nebius"
     provider: str = "Nebius"
 
     api_key: Optional[str] = field(default_factory=lambda: getenv("NEBIUS_API_KEY"))
-    base_url: str = "https://api.studio.nebius.com/v1/"
+    base_url: str = "https://api.tokenfactory.nebius.com/v1/"
 
     def _get_client_params(self) -> Dict[str, Any]:
         if not self.api_key:
-            raise ModelProviderError(
+            raise ModelAuthenticationError(
                 message="NEBIUS_API_KEY not set. Please set the NEBIUS_API_KEY environment variable.",
                 model_name=self.name,
-                model_id=self.id,
             )
 
         # Define base client params

agno/models/nvidia/nvidia.py

@@ -1,7 +1,8 @@
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 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
 
 
@@ -22,7 +23,23 @@ class Nvidia(OpenAILike):
     name: str = "Nvidia"
     provider: str = "Nvidia"
 
-    api_key: Optional[str] = field(default_factory=lambda: getenv("NVIDIA_API_KEY"))
+    api_key: Optional[str] = None
     base_url: str = "https://integrate.api.nvidia.com/v1"
 
     supports_native_structured_outputs: bool = False
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for NVIDIA_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("NVIDIA_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="NVIDIA_API_KEY not set. Please set the NVIDIA_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()

agno/models/ollama/__init__.py

@@ -1,5 +1,7 @@
 from agno.models.ollama.chat import Ollama
+from agno.models.ollama.responses import OllamaResponses
 
 __all__ = [
     "Ollama",
+    "OllamaResponses",
 ]

agno/models/ollama/chat.py

@@ -147,19 +147,26 @@ class Ollama(Model):
         cleaned_dict = {k: v for k, v in model_dict.items() if v is not None}
         return cleaned_dict
 
-    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 Ollama.
 
         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
+
         _message: Dict[str, Any] = {
             "role": message.role,
-            "content": message.content,
+            "content": content,
         }
 
         if message.role == "assistant" and message.tool_calls is not None:
@@ -228,6 +235,7 @@ class Ollama(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 request to the Ollama API.
@@ -241,7 +249,7 @@ class Ollama(Model):
 
         provider_response = self.get_client().chat(
             model=self.id.strip(),
-            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
             **request_kwargs,
         )  # type: ignore
 
@@ -258,6 +266,7 @@ class Ollama(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 request to the Ollama API.
@@ -271,7 +280,7 @@ class Ollama(Model):
 
         provider_response = await self.get_async_client().chat(
             model=self.id.strip(),
-            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
             **request_kwargs,
         )  # type: ignore
 
@@ -288,6 +297,7 @@ class Ollama(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]:
         """
         Sends a streaming chat request to the Ollama API.
@@ -299,7 +309,7 @@ class Ollama(Model):
 
         for chunk in self.get_client().chat(
             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(tools=tools),
         ):
@@ -315,6 +325,7 @@ class Ollama(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 Ollama API.
@@ -326,7 +337,7 @@ class Ollama(Model):
 
         async for chunk in await self.get_async_client().chat(
             model=self.id.strip(),
-            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(tools=tools),
         ):