agno 2.2.13__py3-none-any.whl → 2.4.3__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

@@ -136,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,
@@ -207,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.
@@ -217,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()
@@ -246,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.
@@ -257,7 +259,7 @@ class AzureAIFoundry(Model):
 
             assistant_message.metrics.start_timer()
             provider_response = await self.get_async_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()
@@ -286,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.
@@ -297,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),
             ):
@@ -325,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.
@@ -336,7 +340,7 @@ class AzureAIFoundry(Model):
             assistant_message.metrics.start_timer()
 
             async_stream = await self.get_async_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),
             )

agno/models/azure/openai_chat.py

@@ -4,8 +4,10 @@ from typing import Any, Dict, Optional
 
 import httpx
 
+from agno.exceptions import ModelAuthenticationError
 from agno.models.openai.like import OpenAILike
-from agno.utils.log import log_debug
+from agno.utils.http import get_default_async_client, get_default_sync_client
+from agno.utils.log import log_warning
 
 try:
     from openai import AsyncAzureOpenAI as AsyncAzureOpenAIClient
@@ -62,6 +64,19 @@ class AzureOpenAI(OpenAILike):
         self.api_key = self.api_key or getenv("AZURE_OPENAI_API_KEY")
         self.azure_endpoint = self.azure_endpoint or getenv("AZURE_OPENAI_ENDPOINT")
         self.azure_deployment = self.azure_deployment or getenv("AZURE_OPENAI_DEPLOYMENT")
+
+        if not (self.api_key or self.azure_ad_token):
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="AZURE_OPENAI_API_KEY not set. Please set the AZURE_OPENAI_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+            if not self.azure_ad_token:
+                raise ModelAuthenticationError(
+                    message="AZURE_AD_TOKEN not set. Please set the AZURE_AD_TOKEN environment variable.",
+                    model_name=self.name,
+                )
+
         params_mapping = {
             "api_key": self.api_key,
             "api_version": self.api_version,
@@ -99,7 +114,12 @@ class AzureOpenAI(OpenAILike):
             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()
 
         # Create client
         self.client = AzureOpenAIClient(**_client_params)
@@ -117,15 +137,18 @@ class AzureOpenAI(OpenAILike):
 
         _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()
 
         self.async_client = AsyncAzureOpenAIClient(**_client_params)
         return self.async_client