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

agno/models/aws/bedrock.py

@@ -6,7 +6,7 @@ from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Tuple, Ty
 from pydantic import BaseModel
 
 from agno.exceptions import AgnoError, ModelProviderError
-from agno.models.base import MessageData, Model
+from agno.models.base import Model
 from agno.models.message import Message
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse
@@ -360,7 +360,7 @@ class AwsBedrock(Model):
             formatted_messages, system_message = self._format_messages(messages)
 
             tool_config = None
-            if tools is not None and tools:
+            if tools:
                 tool_config = {"tools": self._format_tools_for_request(tools)}
 
             body = {
@@ -408,7 +408,7 @@ class AwsBedrock(Model):
             formatted_messages, system_message = self._format_messages(messages)
 
             tool_config = None
-            if tools is not None and tools:
+            if tools:
                 tool_config = {"tools": self._format_tools_for_request(tools)}
 
             body = {
@@ -426,10 +426,14 @@ class AwsBedrock(Model):
 
             assistant_message.metrics.start_timer()
 
+            # Track current tool being built across chunks
+            current_tool: Dict[str, Any] = {}
+
             for chunk in self.get_client().converse_stream(modelId=self.id, messages=formatted_messages, **body)[
                 "stream"
             ]:
-                yield self._parse_provider_response_delta(chunk)
+                model_response, current_tool = self._parse_provider_response_delta(chunk, current_tool)
+                yield model_response
 
             assistant_message.metrics.stop_timer()
 
@@ -456,7 +460,7 @@ class AwsBedrock(Model):
             formatted_messages, system_message = self._format_messages(messages)
 
             tool_config = None
-            if tools is not None and tools:
+            if tools:
                 tool_config = {"tools": self._format_tools_for_request(tools)}
 
             body = {
@@ -507,7 +511,7 @@ class AwsBedrock(Model):
             formatted_messages, system_message = self._format_messages(messages)
 
             tool_config = None
-            if tools is not None and tools:
+            if tools:
                 tool_config = {"tools": self._format_tools_for_request(tools)}
 
             body = {
@@ -525,10 +529,14 @@ class AwsBedrock(Model):
 
             assistant_message.metrics.start_timer()
 
+            # Track current tool being built across chunks
+            current_tool: Dict[str, Any] = {}
+
             async with self.get_async_client() as client:
                 response = await client.converse_stream(modelId=self.id, messages=formatted_messages, **body)
                 async for chunk in response["stream"]:
-                    yield self._parse_provider_response_delta(chunk)
+                    model_response, current_tool = self._parse_provider_response_delta(chunk, current_tool)
+                    yield model_response
 
             assistant_message.metrics.stop_timer()
 
@@ -617,122 +625,54 @@ class AwsBedrock(Model):
 
         return model_response
 
-    def process_response_stream(
-        self,
-        messages: List[Message],
-        assistant_message: Message,
-        stream_data: MessageData,
-        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]:
-        """
-        Process the synchronous response stream.
-
-        Args:
-            messages (List[Message]): The messages to include in the request.
-            assistant_message (Message): The assistant message.
-            stream_data (MessageData): The stream data.
-        """
-        for response_delta in self.invoke_stream(
-            messages=messages,
-            assistant_message=assistant_message,
-            response_format=response_format,
-            tools=tools,
-            tool_choice=tool_choice,
-            run_response=run_response,
-        ):
-            should_yield = False
-
-            if response_delta.content:
-                stream_data.response_content += response_delta.content
-                should_yield = True
-
-            if response_delta.tool_calls:
-                if stream_data.response_tool_calls is None:
-                    stream_data.response_tool_calls = []
-                stream_data.response_tool_calls.extend(response_delta.tool_calls)
-                should_yield = True
-
-            if should_yield:
-                yield response_delta
-
-    async def aprocess_response_stream(
-        self,
-        messages: List[Message],
-        assistant_message: Message,
-        stream_data: MessageData,
-        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]:
-        """
-        Process the asynchronous response stream.
-
-        Args:
-            messages (List[Message]): The messages to include in the request.
-            assistant_message (Message): The assistant message.
-            stream_data (MessageData): The stream data.
-        """
-        async for response_delta in self.ainvoke_stream(
-            messages=messages,
-            assistant_message=assistant_message,
-            response_format=response_format,
-            tools=tools,
-            tool_choice=tool_choice,
-            run_response=run_response,
-        ):
-            should_yield = False
-
-            if response_delta.content:
-                stream_data.response_content += response_delta.content
-                should_yield = True
-
-            if response_delta.tool_calls:
-                if stream_data.response_tool_calls is None:
-                    stream_data.response_tool_calls = []
-                stream_data.response_tool_calls.extend(response_delta.tool_calls)
-                should_yield = True
-
-            if should_yield:
-                yield response_delta
-
-        self._populate_assistant_message(assistant_message=assistant_message, provider_response=response_delta)
-
-    def _parse_provider_response_delta(self, response_delta: Dict[str, Any]) -> ModelResponse:  # type: ignore
+    def _parse_provider_response_delta(
+        self, response_delta: Dict[str, Any], current_tool: Dict[str, Any]
+    ) -> Tuple[ModelResponse, Dict[str, Any]]:
         """Parse the provider response delta for streaming.
 
         Args:
             response_delta: The streaming response delta from AWS Bedrock
+            current_tool: The current tool being built across chunks
 
         Returns:
-            ModelResponse: The parsed model response delta
+            Tuple[ModelResponse, Dict[str, Any]]: The parsed model response delta and updated current_tool
         """
         model_response = ModelResponse(role="assistant")
 
-        # Handle contentBlockDelta - text content
-        if "contentBlockDelta" in response_delta:
-            delta = response_delta["contentBlockDelta"]["delta"]
-            if "text" in delta:
-                model_response.content = delta["text"]
-
         # Handle contentBlockStart - tool use start
-        elif "contentBlockStart" in response_delta:
+        if "contentBlockStart" in response_delta:
             start = response_delta["contentBlockStart"]["start"]
             if "toolUse" in start:
-                tool_use = start["toolUse"]
-                model_response.tool_calls = [
-                    {
-                        "id": tool_use.get("toolUseId", ""),
-                        "type": "function",
-                        "function": {
-                            "name": tool_use.get("name", ""),
-                            "arguments": "",  # Will be filled in subsequent deltas
-                        },
-                    }
-                ]
+                # Start a new tool
+                tool_use_data = start["toolUse"]
+                current_tool = {
+                    "id": tool_use_data.get("toolUseId", ""),
+                    "type": "function",
+                    "function": {
+                        "name": tool_use_data.get("name", ""),
+                        "arguments": "",  # Will be filled in subsequent deltas
+                    },
+                }
+
+        # Handle contentBlockDelta - text content or tool input
+        elif "contentBlockDelta" in response_delta:
+            delta = response_delta["contentBlockDelta"]["delta"]
+            if "text" in delta:
+                model_response.content = delta["text"]
+            elif "toolUse" in delta and current_tool:
+                # Accumulate tool input
+                tool_input = delta["toolUse"].get("input", "")
+                if tool_input:
+                    current_tool["function"]["arguments"] += tool_input
+
+        # Handle contentBlockStop - tool use complete
+        elif "contentBlockStop" in response_delta and current_tool:
+            # Tool is complete, add it to model response
+            model_response.tool_calls = [current_tool]
+            # Track tool_id in extra for format_function_call_results
+            model_response.extra = {"tool_ids": [current_tool["id"]]}
+            # Reset current_tool for next tool
+            current_tool = {}
 
         # Handle metadata/usage information
         elif "metadata" in response_delta or "messageStop" in response_delta:
@@ -740,7 +680,7 @@ class AwsBedrock(Model):
             if "usage" in body:
                 model_response.response_usage = self._get_metrics(body["usage"])
 
-        return model_response
+        return model_response, current_tool
 
     def _get_metrics(self, response_usage: Dict[str, Any]) -> Metrics:
         """

agno/models/aws/claude.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass
 from os import getenv
 from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Type, Union
 
+import httpx
 from pydantic import BaseModel
 
 from agno.exceptions import ModelProviderError, ModelRateLimitError
@@ -9,8 +10,9 @@ 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.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.aws_claude import format_messages
+from agno.utils.models.claude import format_messages
 
 try:
     from anthropic import AnthropicBedrock, APIConnectionError, APIStatusError, AsyncAnthropicBedrock, RateLimitError
@@ -99,9 +101,23 @@ class Claude(AnthropicClaude):
                 "aws_region": self.aws_region,
             }
 
+        if self.timeout is not None:
+            client_params["timeout"] = self.timeout
+
         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
         )
@@ -132,9 +148,25 @@ class Claude(AnthropicClaude):
                 "aws_region": self.aws_region,
             }
 
+        if self.timeout is not None:
+            client_params["timeout"] = self.timeout
+
         if self.client_params:
             client_params.update(self.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:
+            # 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
         )

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,
                     ),
                 )
 
@@ -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],
@@ -236,11 +256,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) 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
@@ -316,14 +335,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) 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()
 

agno/models/azure/openai_chat.py

@@ -5,6 +5,8 @@ from typing import Any, Dict, Optional
 import httpx
 
 from agno.models.openai.like import OpenAILike
+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
@@ -70,7 +72,6 @@ class AzureOpenAI(OpenAILike):
             "base_url": self.base_url,
             "azure_ad_token": self.azure_ad_token,
             "azure_ad_token_provider": self.azure_ad_token_provider,
-            "http_client": self.http_client,
         }
         if self.default_headers is not None:
             _client_params["default_headers"] = self.default_headers
@@ -95,7 +96,18 @@ class AzureOpenAI(OpenAILike):
 
         _client_params: Dict[str, Any] = self._get_client_params()
 
-        # -*- Create client
+        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()
+
+        # Create client
         self.client = AzureOpenAIClient(**_client_params)
         return self.client
 
@@ -106,18 +118,23 @@ class AzureOpenAI(OpenAILike):
         Returns:
             AsyncAzureOpenAIClient: An instance of the asynchronous OpenAI client.
         """
-        if self.async_client:
+        if self.async_client and not self.async_client.is_closed():
             return self.async_client
 
         _client_params: Dict[str, Any] = self._get_client_params()
 
         if self.http_client:
-            _client_params["http_client"] = 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:
-            # 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