agno 2.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/models/aws/claude.py

@@ -1,19 +1,17 @@
 from dataclasses import dataclass
 from os import getenv
-from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Type, Union
+from typing import Any, Dict, List, Optional, Type, Union
 
+import httpx
 from pydantic import BaseModel
 
-from agno.exceptions import ModelProviderError, ModelRateLimitError
 from agno.models.anthropic import Claude as AnthropicClaude
-from agno.models.message import Message
-from agno.models.response import ModelResponse
-from agno.run.agent import RunOutput
-from agno.utils.log import log_debug, log_error, log_warning
-from agno.utils.models.claude import format_messages
+from agno.utils.http import get_default_async_client, get_default_sync_client
+from agno.utils.log import log_debug, log_warning
+from agno.utils.models.claude import format_tools_for_model
 
 try:
-    from anthropic import AnthropicBedrock, APIConnectionError, APIStatusError, AsyncAnthropicBedrock, RateLimitError
+    from anthropic import AnthropicBedrock, AsyncAnthropicBedrock
 except ImportError:
     raise ImportError("`anthropic[bedrock]` not installed. Please install using `pip install anthropic[bedrock]`")
 
@@ -31,44 +29,69 @@ class Claude(AnthropicClaude):
     For more information, see: https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-anthropic.html
     """
 
-    id: str = "anthropic.claude-3-5-sonnet-20240620-v1:0"
+    id: str = "global.anthropic.claude-sonnet-4-5-20250929-v1:0"
     name: str = "AwsBedrockAnthropicClaude"
     provider: str = "AwsBedrock"
 
     aws_access_key: Optional[str] = None
     aws_secret_key: Optional[str] = None
     aws_region: Optional[str] = None
+    api_key: Optional[str] = None
     session: Optional[Session] = None
 
-    # -*- Request parameters
-    max_tokens: int = 4096
-    temperature: Optional[float] = None
-    top_p: Optional[float] = None
-    top_k: Optional[int] = None
-    stop_sequences: Optional[List[str]] = None
+    client: Optional[AnthropicBedrock] = None  # type: ignore
+    async_client: Optional[AsyncAnthropicBedrock] = None  # type: ignore
 
-    # -*- Request parameters
-    request_params: Optional[Dict[str, Any]] = None
-    # -*- Client parameters
-    client_params: Optional[Dict[str, Any]] = None
+    def __post_init__(self):
+        """Validate model configuration after initialization"""
+        # Validate thinking support immediately at model creation
+        if self.thinking:
+            self._validate_thinking_support()
+        # Overwrite output schema support for AWS Bedrock Claude
+        self.supports_native_structured_outputs = False
+        self.supports_json_schema_outputs = False
 
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Convert the model to a dictionary.
+    def _get_client_params(self) -> Dict[str, Any]:
+        if self.session:
+            credentials = self.session.get_credentials()
+            client_params: Dict[str, Any] = {
+                "aws_access_key": credentials.access_key,
+                "aws_secret_key": credentials.secret_key,
+                "aws_session_token": credentials.token,
+                "aws_region": self.session.region_name,
+            }
+        else:
+            self.api_key = self.api_key or getenv("AWS_BEDROCK_API_KEY")
+            if self.api_key:
+                self.aws_region = self.aws_region or getenv("AWS_REGION")
+                client_params = {
+                    "api_key": self.api_key,
+                }
+                if self.aws_region:
+                    client_params["aws_region"] = self.aws_region
+            else:
+                self.aws_access_key = self.aws_access_key or getenv("AWS_ACCESS_KEY_ID") or getenv("AWS_ACCESS_KEY")
+                self.aws_secret_key = self.aws_secret_key or getenv("AWS_SECRET_ACCESS_KEY") or getenv("AWS_SECRET_KEY")
+                self.aws_region = self.aws_region or getenv("AWS_REGION")
+
+                client_params = {
+                    "aws_secret_key": self.aws_secret_key,
+                    "aws_access_key": self.aws_access_key,
+                    "aws_region": self.aws_region,
+                }
+
+            if not (self.api_key or (self.aws_access_key and self.aws_secret_key)):
+                log_warning(
+                    "AWS credentials not found. Please set AWS_BEDROCK_API_KEY or AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables or provide a boto3 session."
+                )
+
+        if self.timeout is not None:
+            client_params["timeout"] = self.timeout
 
-        Returns:
-            Dict[str, Any]: The dictionary representation of the model.
-        """
-        _dict = super().to_dict()
-        _dict["max_tokens"] = self.max_tokens
-        _dict["temperature"] = self.temperature
-        _dict["top_p"] = self.top_p
-        _dict["top_k"] = self.top_k
-        _dict["stop_sequences"] = self.stop_sequences
-        return _dict
+        if self.client_params:
+            client_params.update(self.client_params)
 
-    client: Optional[AnthropicBedrock] = None  # type: ignore
-    async_client: Optional[AsyncAnthropicBedrock] = None  # type: ignore
+        return client_params
 
     def get_client(self):
         """
@@ -80,27 +103,18 @@ class Claude(AnthropicClaude):
         if self.client is not None and not self.client.is_closed():
             return self.client
 
-        if self.session:
-            credentials = self.session.get_credentials()
-            client_params = {
-                "aws_access_key": credentials.access_key,
-                "aws_secret_key": credentials.secret_key,
-                "aws_session_token": credentials.token,
-                "aws_region": self.session.region_name,
-            }
-        else:
-            self.aws_access_key = self.aws_access_key or getenv("AWS_ACCESS_KEY")
-            self.aws_secret_key = self.aws_secret_key or getenv("AWS_SECRET_KEY")
-            self.aws_region = self.aws_region or getenv("AWS_REGION")
-
-            client_params = {
-                "aws_secret_key": self.aws_secret_key,
-                "aws_access_key": self.aws_access_key,
-                "aws_region": self.aws_region,
-            }
+        client_params = self._get_client_params()
 
-        if self.client_params:
-            client_params.update(self.client_params)
+        if self.http_client:
+            if isinstance(self.http_client, httpx.Client):
+                client_params["http_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["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 = AnthropicBedrock(
             **client_params,  # type: ignore
@@ -117,39 +131,46 @@ class Claude(AnthropicClaude):
         if self.async_client is not None:
             return self.async_client
 
-        if self.session:
-            credentials = self.session.get_credentials()
-            client_params = {
-                "aws_access_key": credentials.access_key,
-                "aws_secret_key": credentials.secret_key,
-                "aws_session_token": credentials.token,
-                "aws_region": self.session.region_name,
-            }
+        client_params = self._get_client_params()
+
+        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:
-            client_params = {
-                "aws_secret_key": self.aws_secret_key,
-                "aws_access_key": self.aws_access_key,
-                "aws_region": self.aws_region,
-            }
-
-        if self.client_params:
-            client_params.update(self.client_params)
+            # Use global async client when no custom http_client is provided
+            client_params["http_client"] = get_default_async_client()
 
         self.async_client = AsyncAnthropicBedrock(
             **client_params,  # type: ignore
         )
         return self.async_client
 
-    def get_request_params(self) -> Dict[str, Any]:
+    def get_request_params(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
         """
         Generate keyword arguments for API requests.
 
         Returns:
             Dict[str, Any]: The keyword arguments for API requests.
         """
+        # Validate thinking support if thinking is enabled
+        if self.thinking:
+            self._validate_thinking_support()
+
         _request_params: Dict[str, Any] = {}
         if self.max_tokens:
             _request_params["max_tokens"] = self.max_tokens
+        if self.thinking:
+            _request_params["thinking"] = self.thinking
         if self.temperature:
             _request_params["temperature"] = self.temperature
         if self.stop_sequences:
@@ -158,6 +179,16 @@ class Claude(AnthropicClaude):
             _request_params["top_p"] = self.top_p
         if self.top_k:
             _request_params["top_k"] = self.top_k
+        if self.timeout:
+            _request_params["timeout"] = self.timeout
+
+        # Build betas list - include existing betas and add new one if needed
+        betas_list = list(self.betas) if self.betas else []
+
+        # Include betas if any are present
+        if betas_list:
+            _request_params["betas"] = betas_list
+
         if self.request_params:
             _request_params.update(self.request_params)
 
@@ -165,214 +196,40 @@ class Claude(AnthropicClaude):
             log_debug(f"Calling {self.provider} with request parameters: {_request_params}", log_level=2)
         return _request_params
 
-    def invoke(
-        self,
-        messages: List[Message],
-        assistant_message: Message,
-        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,
-    ) -> ModelResponse:
-        """
-        Send a request to the Anthropic API to generate a response.
-        """
-
-        try:
-            chat_messages, system_message = format_messages(messages)
-            request_kwargs = self._prepare_request_kwargs(system_message, tools)
-
-            if run_response and run_response.metrics:
-                run_response.metrics.set_time_to_first_token()
-
-            assistant_message.metrics.start_timer()
-            response = self.get_client().messages.create(
-                model=self.id,
-                messages=chat_messages,  # type: ignore
-                **request_kwargs,
-            )
-            assistant_message.metrics.stop_timer()
-
-            model_response = self._parse_provider_response(response, response_format=response_format)
-
-            return model_response
-
-        except APIConnectionError as e:
-            log_error(f"Connection error while calling Claude API: {str(e)}")
-            raise ModelProviderError(message=e.message, model_name=self.name, model_id=self.id) from e
-        except RateLimitError as e:
-            log_warning(f"Rate limit exceeded: {str(e)}")
-            raise ModelRateLimitError(message=e.message, model_name=self.name, model_id=self.id) from e
-        except APIStatusError as e:
-            log_error(f"Claude API error (status {e.status_code}): {str(e)}")
-            raise ModelProviderError(
-                message=e.message, status_code=e.status_code, model_name=self.name, model_id=self.id
-            ) from e
-        except Exception as e:
-            log_error(f"Unexpected error calling Claude API: {str(e)}")
-            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
-
-    def invoke_stream(
-        self,
-        messages: List[Message],
-        assistant_message: Message,
-        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]:
-        """
-        Stream a response from the Anthropic API.
-
-        Args:
-            messages (List[Message]): A list of messages to send to the model.
-
-        Returns:
-            Any: The streamed response from the model.
-
-        Raises:
-            APIConnectionError: If there are network connectivity issues
-            RateLimitError: If the API rate limit is exceeded
-            APIStatusError: For other API-related errors
-        """
-
-        chat_messages, system_message = format_messages(messages)
-        request_kwargs = self._prepare_request_kwargs(system_message, tools)
-
-        try:
-            if run_response and run_response.metrics:
-                run_response.metrics.set_time_to_first_token()
-
-            assistant_message.metrics.start_timer()
-
-            with self.get_client().messages.stream(
-                model=self.id,
-                messages=chat_messages,  # type: ignore
-                **request_kwargs,
-            ) as stream:
-                for chunk in stream:
-                    yield self._parse_provider_response_delta(chunk)
-
-            assistant_message.metrics.stop_timer()
-
-        except APIConnectionError as e:
-            log_error(f"Connection error while calling Claude API: {str(e)}")
-            raise ModelProviderError(message=e.message, model_name=self.name, model_id=self.id) from e
-        except RateLimitError as e:
-            log_warning(f"Rate limit exceeded: {str(e)}")
-            raise ModelRateLimitError(message=e.message, model_name=self.name, model_id=self.id) from e
-        except APIStatusError as e:
-            log_error(f"Claude API error (status {e.status_code}): {str(e)}")
-            raise ModelProviderError(
-                message=e.message, status_code=e.status_code, model_name=self.name, model_id=self.id
-            ) from e
-        except Exception as e:
-            log_error(f"Unexpected error calling Claude API: {str(e)}")
-            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
-
-    async def ainvoke(
+    def _prepare_request_kwargs(
         self,
-        messages: List[Message],
-        assistant_message: Message,
-        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        system_message: str,
         tools: Optional[List[Dict[str, Any]]] = None,
-        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
-        run_response: Optional[RunOutput] = None,
-    ) -> ModelResponse:
-        """
-        Send an asynchronous request to the Anthropic API to generate a response.
-        """
-
-        try:
-            chat_messages, system_message = format_messages(messages)
-            request_kwargs = self._prepare_request_kwargs(system_message, tools)
-
-            if run_response and run_response.metrics:
-                run_response.metrics.set_time_to_first_token()
-
-            assistant_message.metrics.start_timer()
-
-            response = await self.get_async_client().messages.create(
-                model=self.id,
-                messages=chat_messages,  # type: ignore
-                **request_kwargs,
-            )
-
-            assistant_message.metrics.stop_timer()
-
-            model_response = self._parse_provider_response(response, response_format=response_format)
-
-            return model_response
-
-        except APIConnectionError as e:
-            log_error(f"Connection error while calling Claude API: {str(e)}")
-            raise ModelProviderError(message=e.message, model_name=self.name, model_id=self.id) from e
-        except RateLimitError as e:
-            log_warning(f"Rate limit exceeded: {str(e)}")
-            raise ModelRateLimitError(message=e.message, model_name=self.name, model_id=self.id) from e
-        except APIStatusError as e:
-            log_error(f"Claude API error (status {e.status_code}): {str(e)}")
-            raise ModelProviderError(
-                message=e.message, status_code=e.status_code, model_name=self.name, model_id=self.id
-            ) from e
-        except Exception as e:
-            log_error(f"Unexpected error calling Claude API: {str(e)}")
-            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
-
-    async def ainvoke_stream(
-        self,
-        messages: List[Message],
-        assistant_message: Message,
         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]:
+    ) -> Dict[str, Any]:
         """
-        Stream an asynchronous response from the Anthropic API.
+        Prepare the request keyword arguments for the API call.
 
         Args:
-            messages (List[Message]): A list of messages to send to the model.
+            system_message (str): The concatenated system messages.
+            tools: Optional list of tools
+            response_format: Optional response format (Pydantic model or dict)
 
         Returns:
-            Any: The streamed response from the model.
-
-        Raises:
-            APIConnectionError: If there are network connectivity issues
-            RateLimitError: If the API rate limit is exceeded
-            APIStatusError: For other API-related errors
-        """
-
-        try:
-            chat_messages, system_message = format_messages(messages)
-            request_kwargs = self._prepare_request_kwargs(system_message, tools)
-
-            if run_response and run_response.metrics:
-                run_response.metrics.set_time_to_first_token()
-
-            assistant_message.metrics.start_timer()
-
-            async with self.get_async_client().messages.stream(
-                model=self.id,
-                messages=chat_messages,  # type: ignore
-                **request_kwargs,
-            ) as stream:
-                async for chunk in stream:
-                    yield self._parse_provider_response_delta(chunk)
-
-            assistant_message.metrics.stop_timer()
-
-        except APIConnectionError as e:
-            log_error(f"Connection error while calling Claude API: {str(e)}")
-            raise ModelProviderError(message=e.message, model_name=self.name, model_id=self.id) from e
-        except RateLimitError as e:
-            log_warning(f"Rate limit exceeded: {str(e)}")
-            raise ModelRateLimitError(message=e.message, model_name=self.name, model_id=self.id) from e
-        except APIStatusError as e:
-            log_error(f"Claude API error (status {e.status_code}): {str(e)}")
-            raise ModelProviderError(
-                message=e.message, status_code=e.status_code, model_name=self.name, model_id=self.id
-            ) from e
-        except Exception as e:
-            log_error(f"Unexpected error calling Claude API: {str(e)}")
-            raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
+            Dict[str, Any]: The request keyword arguments.
+        """
+        # Pass response_format and tools to get_request_params for beta header handling
+        request_kwargs = self.get_request_params(response_format=response_format, tools=tools).copy()
+        if system_message:
+            if self.cache_system_prompt:
+                cache_control = (
+                    {"type": "ephemeral", "ttl": "1h"}
+                    if self.extended_cache_time is not None and self.extended_cache_time is True
+                    else {"type": "ephemeral"}
+                )
+                request_kwargs["system"] = [{"text": system_message, "type": "text", "cache_control": cache_control}]
+            else:
+                request_kwargs["system"] = [{"text": system_message, "type": "text"}]
+
+        # Format tools (this will handle strict mode)
+        if tools:
+            request_kwargs["tools"] = format_tools_for_model(tools)
+
+        if request_kwargs:
+            log_debug(f"Calling {self.provider} with request parameters: {request_kwargs}", log_level=2)
+        return request_kwargs

agno/models/azure/ai_foundry.py

@@ -60,6 +60,7 @@ class AzureAIFoundry(Model):
     stop: Optional[Union[str, List[str]]] = None
     seed: Optional[int] = None
     model_extras: Optional[Dict[str, Any]] = 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
     request_params: Optional[Dict[str, Any]] = None
     # Client parameters
     api_key: Optional[str] = None
@@ -116,7 +117,7 @@ class AzureAIFoundry(Model):
                         name=response_format.__name__,
                         schema=response_format.model_json_schema(),  # type: ignore
                         description=response_format.__doc__,
-                        strict=True,
+                        strict=self.strict_output,
                     ),
                 )
 
@@ -135,9 +136,9 @@ class AzureAIFoundry(Model):
         self.azure_endpoint = self.azure_endpoint or getenv("AZURE_ENDPOINT")
 
         if not self.api_key:
-            raise ValueError("API key is required")
+            log_error("AZURE_API_KEY not set. Please set the AZURE_API_KEY environment variable.")
         if not self.azure_endpoint:
-            raise ValueError("Endpoint URL is required")
+            log_error("AZURE_ENDPOINT not set. Please set the AZURE_ENDPOINT environment variable.")
 
         base_params = {
             "endpoint": self.azure_endpoint,
@@ -160,7 +161,9 @@ class AzureAIFoundry(Model):
         Returns:
             ChatCompletionsClient: An instance of the Azure AI client.
         """
-        if self.client:
+        # Check if client exists and is not closed
+        # Azure's client doesn't have is_closed(), so we check if _client exists
+        if self.client and hasattr(self.client, "_client"):
             return self.client
 
         client_params = self._get_client_params()
@@ -174,11 +177,28 @@ class AzureAIFoundry(Model):
         Returns:
             AsyncChatCompletionsClient: An instance of the asynchronous Azure AI client.
         """
+        # Check if client exists and is not closed
+        # Azure's async client doesn't have is_closed(), so we check if _client exists
+        if self.async_client and hasattr(self.async_client, "_client"):
+            return self.async_client
+
         client_params = self._get_client_params()
 
         self.async_client = AsyncChatCompletionsClient(**client_params)
         return self.async_client
 
+    def close(self) -> None:
+        """Close the synchronous client and clean up resources."""
+        if self.client:
+            self.client.close()
+            self.client = None
+
+    async def aclose(self) -> None:
+        """Close the asynchronous client and clean up resources."""
+        if self.async_client:
+            await self.async_client.close()
+            self.async_client = None
+
     def invoke(
         self,
         messages: List[Message],
@@ -187,6 +207,7 @@ class AzureAIFoundry(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 Azure AI API.
@@ -197,7 +218,7 @@ class AzureAIFoundry(Model):
 
             assistant_message.metrics.start_timer()
             provider_response = self.get_client().complete(
-                messages=[format_message(m) for m in messages],
+                messages=[format_message(m, compress_tool_results) for m in messages],
                 **self.get_request_params(tools=tools, response_format=response_format, tool_choice=tool_choice),
             )
             assistant_message.metrics.stop_timer()
@@ -226,6 +247,7 @@ class AzureAIFoundry(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 Azure AI API.
@@ -236,11 +258,10 @@ class AzureAIFoundry(Model):
                 run_response.metrics.set_time_to_first_token()
 
             assistant_message.metrics.start_timer()
-            async with self.get_async_client() as client:
-                provider_response = await client.complete(
-                    messages=[format_message(m) for m in messages],
-                    **self.get_request_params(tools=tools, response_format=response_format, tool_choice=tool_choice),
-                )
+            provider_response = await self.get_async_client().complete(
+                messages=[format_message(m, compress_tool_results) for m in messages],
+                **self.get_request_params(tools=tools, response_format=response_format, tool_choice=tool_choice),
+            )
             assistant_message.metrics.stop_timer()
 
             model_response = self._parse_provider_response(provider_response, response_format=response_format)  # type: ignore
@@ -267,6 +288,7 @@ class AzureAIFoundry(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 Azure AI API.
@@ -278,7 +300,7 @@ class AzureAIFoundry(Model):
             assistant_message.metrics.start_timer()
 
             for chunk in self.get_client().complete(
-                messages=[format_message(m) for m in messages],
+                messages=[format_message(m, compress_tool_results) for m in messages],
                 stream=True,
                 **self.get_request_params(tools=tools, response_format=response_format, tool_choice=tool_choice),
             ):
@@ -306,6 +328,7 @@ class AzureAIFoundry(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 Azure AI API.
@@ -316,14 +339,13 @@ class AzureAIFoundry(Model):
 
             assistant_message.metrics.start_timer()
 
-            async with self.get_async_client() as client:
-                async_stream = await client.complete(
-                    messages=[format_message(m) for m in messages],
-                    stream=True,
-                    **self.get_request_params(tools=tools, response_format=response_format, tool_choice=tool_choice),
-                )
-                async for chunk in async_stream:  # type: ignore
-                    yield self._parse_provider_response_delta(chunk)
+            async_stream = await self.get_async_client().complete(
+                messages=[format_message(m, compress_tool_results) for m in messages],
+                stream=True,
+                **self.get_request_params(tools=tools, response_format=response_format, tool_choice=tool_choice),
+            )
+            async for chunk in async_stream:  # type: ignore
+                yield self._parse_provider_response_delta(chunk)
 
             assistant_message.metrics.stop_timer()