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

agno/models/aws/claude.py

@@ -1,228 +1,235 @@
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from os import getenv
+from typing import Any, Dict, List, Optional, Type, Union
 
-from agno.models.aws.bedrock import AwsBedrock
-from agno.models.message import Message
+import httpx
+from pydantic import BaseModel
+
+from agno.models.anthropic import Claude as AnthropicClaude
+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, AsyncAnthropicBedrock
+except ImportError:
+    raise ImportError("`anthropic[bedrock]` not installed. Please install using `pip install anthropic[bedrock]`")
+
+try:
+    from boto3.session import Session
+except ImportError:
+    raise ImportError("`boto3` not installed. Please install using `pip install boto3`")
 
 
 @dataclass
-class Claude(AwsBedrock):
+class Claude(AnthropicClaude):
     """
     AWS Bedrock Claude model.
 
-    Args:
-        id (str): The model to use.
-        max_tokens (int): The maximum number of tokens to generate.
-        temperature (Optional[float]): The temperature to use.
-        top_p (Optional[float]): The top p to use.
-        top_k (Optional[int]): The top k to use.
-        stop_sequences (Optional[List[str]]): The stop sequences to use.
-        anthropic_version (str): The anthropic version to use.
-        request_params (Optional[Dict[str, Any]]): The request parameters to use.
-        client_params (Optional[Dict[str, Any]]): The client parameters to use.
-
+    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"
 
-    # -*- 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
-    anthropic_version: str = "bedrock-2023-05-31"
-
-    # -*- Request parameters
-    request_params: Optional[Dict[str, Any]] = None
-    # -*- Client parameters
-    client_params: Optional[Dict[str, Any]] = None
-
-    def to_dict(self) -> Dict[str, Any]:
-        _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
-
-    @property
-    def api_kwargs(self) -> Dict[str, Any]:
-        _request_params: Dict[str, Any] = {
-            "max_tokens": self.max_tokens,
-            "anthropic_version": self.anthropic_version,
-        }
-        if self.temperature:
-            _request_params["temperature"] = self.temperature
-        if self.top_p:
-            _request_params["top_p"] = self.top_p
-        if self.top_k:
-            _request_params["top_k"] = self.top_k
-        if self.stop_sequences:
-            _request_params["stop_sequences"] = self.stop_sequences
-        if self.request_params:
-            _request_params.update(self.request_params)
-        return _request_params
-
-    def get_tools(self) -> Optional[Dict[str, Any]]:
-        """
-        Refactors the tools in a format accepted by the Bedrock API.
-        """
-        if not self._functions:
-            return None
-
-        tools = []
-        for f_name, function in self._functions.items():
-            properties = {}
-            required = []
-
-            for param_name, param_info in function.parameters.get("properties", {}).items():
-                param_type = param_info.get("type")
-                if isinstance(param_type, list):
-                    param_type = [t for t in param_type if t != "null"][0]
-
-                properties[param_name] = {
-                    "type": param_type or "string",
-                    "description": param_info.get("description") or "",
+    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
+
+    client: Optional[AnthropicBedrock] = None  # type: ignore
+    async_client: Optional[AsyncAnthropicBedrock] = None  # type: ignore
+
+    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 _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 "null" not in (
-                    param_info.get("type") if isinstance(param_info.get("type"), list) else [param_info.get("type")]
-                ):
-                    required.append(param_name)
-
-            tools.append(
-                {
-                    "toolSpec": {
-                        "name": f_name,
-                        "description": function.description or "",
-                        "inputSchema": {"json": {"type": "object", "properties": properties, "required": required}},
-                    }
+                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,
                 }
-            )
 
-        return {"tools": tools}
+            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."
+                )
 
-    def get_request_body(self, messages: List[Message]) -> Dict[str, Any]:
-        """
-        Get the request body for the Bedrock API.
+        if self.timeout is not None:
+            client_params["timeout"] = self.timeout
 
-        Args:
-            messages (List[Message]): The messages to include in the request.
+        if self.client_params:
+            client_params.update(self.client_params)
 
-        Returns:
-            Dict[str, Any]: The request body for the Bedrock API.
+        return client_params
+
+    def get_client(self):
         """
-        system_prompt = None
-        messages_for_api = []
-        for m in messages:
-            if m.role == "system":
-                system_prompt = m.content
-            else:
-                messages_for_api.append({"role": m.role, "content": [{"text": m.content}]})
+        Get the Bedrock client.
 
-        request_body = {
-            "messages": messages_for_api,
-            "modelId": self.id,
-        }
+        Returns:
+            AnthropicBedrock: The Bedrock client.
+        """
+        if self.client is not None and not self.client.is_closed():
+            return self.client
 
-        if system_prompt:
-            request_body["system"] = [{"text": system_prompt}]
+        client_params = self._get_client_params()
 
-        # Add inferenceConfig
-        inference_config: Dict[str, Any] = {}
-        rename_map = {"max_tokens": "maxTokens", "top_p": "topP", "top_k": "topK", "stop_sequences": "stopSequences"}
+        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
+        )
+        return self.client
 
-        for k, v in self.api_kwargs.items():
-            if k in rename_map:
-                inference_config[rename_map[k]] = v
-            elif k in ["temperature"]:
-                inference_config[k] = v
+    def get_async_client(self):
+        """
+        Get the Bedrock async client.
 
-        if inference_config:
-            request_body["inferenceConfig"] = inference_config  # type: ignore
+        Returns:
+            AsyncAnthropicBedrock: The Bedrock async client.
+        """
+        if self.async_client is not None:
+            return self.async_client
 
-        if self.tools:
-            tools = self.get_tools()
-            request_body["toolConfig"] = tools  # type: ignore
+        client_params = self._get_client_params()
 
-        return request_body
+        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
+        )
+        return self.async_client
 
-    def parse_response_message(self, response: Dict[str, Any]) -> 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]:
         """
-        Parse the response from the Bedrock API.
-
-        Args:
-            response (Dict[str, Any]): The response from the Bedrock API.
+        Generate keyword arguments for API requests.
 
         Returns:
-            Dict[str, Any]: The parsed response.
+            Dict[str, Any]: The keyword arguments for API requests.
         """
-        res = {}
-        if "output" in response and "message" in response["output"]:
-            message = response["output"]["message"]
-            role = message.get("role")
-            content = message.get("content", [])
-
-            # Extract text content if it's a list of dictionaries
-            if isinstance(content, list) and content and isinstance(content[0], dict):
-                content = [item.get("text", "") for item in content if "text" in item]
-                content = "\n".join(content)  # Join multiple text items if present
-
-            res = {
-                "content": content,
-                "usage": {
-                    "inputTokens": response.get("usage", {}).get("inputTokens"),
-                    "outputTokens": response.get("usage", {}).get("outputTokens"),
-                    "totalTokens": response.get("usage", {}).get("totalTokens"),
-                },
-                "metrics": {"latencyMs": response.get("metrics", {}).get("latencyMs")},
-                "role": role,
-            }
+        # 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:
+            _request_params["stop_sequences"] = self.stop_sequences
+        if self.top_p:
+            _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
 
-        stop_reason = None
-        if "stopReason" in response:
-            stop_reason = response["stopReason"]
+        # Build betas list - include existing betas and add new one if needed
+        betas_list = list(self.betas) if self.betas else []
 
-        res["stop_reason"] = stop_reason if stop_reason else None
-        res["tool_requests"] = None
+        # Include betas if any are present
+        if betas_list:
+            _request_params["betas"] = betas_list
 
-        if stop_reason == "tool_use":
-            tool_requests = response["output"]["message"]["content"]
-            res["tool_requests"] = tool_requests
+        if self.request_params:
+            _request_params.update(self.request_params)
 
-        return res
+        if _request_params:
+            log_debug(f"Calling {self.provider} with request parameters: {_request_params}", log_level=2)
+        return _request_params
 
-    def create_assistant_message(self, parsed_response: Dict[str, Any]) -> Message:
+    def _prepare_request_kwargs(
+        self,
+        system_message: str,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+    ) -> Dict[str, Any]:
         """
-        Create an assistant message from the parsed response.
+        Prepare the request keyword arguments for the API call.
 
         Args:
-            parsed_response (Dict[str, Any]): The parsed response from the Bedrock API.
+            system_message (str): The concatenated system messages.
+            tools: Optional list of tools
+            response_format: Optional response format (Pydantic model or dict)
 
         Returns:
-            Message: The assistant message.
-        """
-
-        return Message(
-            role=parsed_response["role"],
-            content=parsed_response["content"],
-            metrics=parsed_response["metrics"],
-        )
-
-    def parse_response_delta(self, response: Dict[str, Any]) -> Optional[str]:
+            Dict[str, Any]: The request keyword arguments.
         """
-        Parse the response delta from the Bedrock API.
+        # 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"}]
 
-        Args:
-            response (Dict[str, Any]): The response from the Bedrock API.
+        # Format tools (this will handle strict mode)
+        if tools:
+            request_kwargs["tools"] = format_tools_for_model(tools)
 
-        Returns:
-            Optional[str]: The response delta.
-        """
-        if "delta" in response:
-            return response.get("delta", {}).get("text")
-        return response.get("completion")
+        if request_kwargs:
+            log_debug(f"Calling {self.provider} with request parameters: {request_kwargs}", log_level=2)
+        return request_kwargs

agno/models/azure/__init__.py

@@ -1 +1,18 @@
-from agno.models.azure.openai_chat import AzureOpenAI
+try:
+    from agno.models.azure.ai_foundry import AzureAIFoundry
+except ImportError:
+
+    class AzureAIFoundry:  # type: ignore
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                "`azure-ai-inference` not installed. Please install it via `pip install azure-ai-inference aiohttp`"
+            )
+
+
+try:
+    from agno.models.azure.openai_chat import AzureOpenAI
+except ImportError:
+
+    class AzureOpenAI:  # type: ignore
+        def __init__(self, *args, **kwargs):
+            raise ImportError("`openai` not installed. Please install it via `pip install openai`")