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

agno/models/aimlapi/aimlapi.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
 from typing import Any, Dict, Optional
 
@@ -24,7 +24,7 @@ class AIMLAPI(OpenAILike):
     name: str = "AIMLAPI"
     provider: str = "AIMLAPI"
 
-    api_key: Optional[str] = getenv("AIMLAPI_API_KEY")
+    api_key: Optional[str] = field(default_factory=lambda: getenv("AIMLAPI_API_KEY"))
     base_url: str = "https://api.aimlapi.com/v1"
     max_tokens: int = 4096
 

agno/models/anthropic/claude.py

@@ -4,6 +4,7 @@ from dataclasses import asdict, dataclass
 from os import getenv
 from typing import Any, Dict, List, Optional, Type, Union
 
+import httpx
 from pydantic import BaseModel
 
 from agno.exceptions import ModelProviderError, ModelRateLimitError
@@ -12,6 +13,7 @@ from agno.models.message import Citations, DocumentCitation, Message, UrlCitatio
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse
 from agno.run.agent import RunOutput
+from agno.utils.http import get_default_async_client, get_default_sync_client
 from agno.utils.log import log_debug, log_error, log_warning
 from agno.utils.models.claude import MCPServerConfiguration, format_messages, format_tools_for_model
 
@@ -25,6 +27,11 @@ try:
     from anthropic import (
         AsyncAnthropic as AsyncAnthropicClient,
     )
+    from anthropic.lib.streaming._beta_types import (
+        BetaRawContentBlockStartEvent,
+        ParsedBetaContentBlockStopEvent,
+        ParsedBetaMessageStopEvent,
+    )
     from anthropic.types import (
         CitationPageLocation,
         CitationsWebSearchResultLocation,
@@ -39,12 +46,15 @@ try:
     from anthropic.types import (
         Message as AnthropicMessage,
     )
+
 except ImportError as e:
     raise ImportError("`anthropic` not installed. Please install it with `pip install anthropic`") from e
 
 # Import Beta types
 try:
     from anthropic.types.beta import BetaRawContentBlockDeltaEvent, BetaTextDelta
+    from anthropic.types.beta.beta_message import BetaMessage
+    from anthropic.types.beta.beta_usage import BetaUsage
 except ImportError as e:
     raise ImportError(
         "`anthropic` not installed or missing beta components. Please install with `pip install anthropic`"
@@ -59,12 +69,23 @@ class Claude(Model):
     For more information, see: https://docs.anthropic.com/en/api/messages
     """
 
-    id: str = "claude-3-5-sonnet-20241022"
+    # Models that DO NOT support extended thinking
+    # All future models are assumed to support thinking
+    # Based on official Anthropic documentation: https://docs.claude.com/en/docs/about-claude/models/overview
+    NON_THINKING_MODELS = {
+        # Claude Haiku 3 family (does not support thinking)
+        "claude-3-haiku-20240307",
+        # Claude Haiku 3.5 family (does not support thinking)
+        "claude-3-5-haiku-20241022",
+        "claude-3-5-haiku-latest",
+    }
+
+    id: str = "claude-sonnet-4-5-20250929"
     name: str = "Claude"
     provider: str = "Anthropic"
 
     # Request parameters
-    max_tokens: Optional[int] = 4096
+    max_tokens: Optional[int] = 8192
     thinking: Optional[Dict[str, Any]] = None
     temperature: Optional[float] = None
     stop_sequences: Optional[List[str]] = None
@@ -73,17 +94,34 @@ class Claude(Model):
     cache_system_prompt: Optional[bool] = False
     extended_cache_time: Optional[bool] = False
     request_params: Optional[Dict[str, Any]] = None
+
+    # Anthropic beta and experimental features
+    betas: Optional[List[str]] = None  # Enables specific experimental or newly released features.
+    context_management: Optional[Dict[str, Any]] = None
     mcp_servers: Optional[List[MCPServerConfiguration]] = None
+    skills: Optional[List[Dict[str, str]]] = (
+        None  # e.g., [{"type": "anthropic", "skill_id": "pptx", "version": "latest"}]
+    )
 
     # Client parameters
     api_key: Optional[str] = None
     default_headers: Optional[Dict[str, Any]] = None
+    timeout: Optional[float] = None
+    http_client: Optional[Union[httpx.Client, httpx.AsyncClient]] = None
     client_params: Optional[Dict[str, Any]] = None
 
-    # Anthropic clients
     client: Optional[AnthropicClient] = None
     async_client: Optional[AsyncAnthropicClient] = None
 
+    def __post_init__(self):
+        """Validate model configuration after initialization"""
+        # Validate thinking support immediately at model creation
+        if self.thinking:
+            self._validate_thinking_support()
+        # Set up skills configuration if skills are enabled
+        if self.skills:
+            self._setup_skills_configuration()
+
     def _get_client_params(self) -> Dict[str, Any]:
         client_params: Dict[str, Any] = {}
 
@@ -93,6 +131,8 @@ class Claude(Model):
 
         # Add API key to client parameters
         client_params["api_key"] = self.api_key
+        if self.timeout is not None:
+            client_params["timeout"] = self.timeout
 
         # Add additional client parameters
         if self.client_params is not None:
@@ -101,6 +141,15 @@ class Claude(Model):
             client_params["default_headers"] = self.default_headers
         return client_params
 
+    def _has_beta_features(self) -> bool:
+        """Check if the model has any Anthropic beta features enabled."""
+        return (
+            self.mcp_servers is not None
+            or self.context_management is not None
+            or self.skills is not None
+            or self.betas is not None
+        )
+
     def get_client(self) -> AnthropicClient:
         """
         Returns an instance of the Anthropic client.
@@ -109,6 +158,16 @@ class Claude(Model):
             return self.client
 
         _client_params = self._get_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 = AnthropicClient(**_client_params)
         return self.client
 
@@ -116,17 +175,69 @@ class Claude(Model):
         """
         Returns an instance of the async Anthropic client.
         """
-        if self.async_client:
+        if self.async_client and not self.async_client.is_closed():
             return self.async_client
 
         _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:
+            # Use global async client when no custom http_client is provided
+            _client_params["http_client"] = get_default_async_client()
         self.async_client = AsyncAnthropicClient(**_client_params)
         return self.async_client
 
+    def _validate_thinking_support(self) -> None:
+        """
+        Validate that the current model supports extended thinking.
+
+        Raises:
+            ValueError: If thinking is enabled but the model doesn't support it
+        """
+        if self.thinking and self.id in self.NON_THINKING_MODELS:
+            non_thinking_models = "\n  - ".join(sorted(self.NON_THINKING_MODELS))
+            raise ValueError(
+                f"Model '{self.id}' does not support extended thinking.\n\n"
+                f"The following models do NOT support thinking:\n  - {non_thinking_models}\n\n"
+                f"All other Claude models support extended thinking by default.\n"
+                f"For more information, see: https://docs.anthropic.com/en/docs/about-claude/models/overview"
+            )
+
+    def _setup_skills_configuration(self) -> None:
+        """
+        Set up configuration for Claude Agent Skills.
+        Automatically configures betas array with required values.
+
+        Skills enable document creation capabilities (PowerPoint, Excel, Word, PDF).
+        For more information, see: https://docs.claude.com/en/docs/agents-and-tools/agent-skills/quickstart
+        """
+        # Required betas for skills
+        required_betas = ["code-execution-2025-08-25", "skills-2025-10-02"]
+
+        # Initialize or merge betas
+        if self.betas is None:
+            self.betas = required_betas
+        else:
+            # Add required betas if not present
+            for beta in required_betas:
+                if beta not in self.betas:
+                    self.betas.append(beta)
+
     def get_request_params(self) -> Dict[str, Any]:
         """
         Generate 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
@@ -140,10 +251,17 @@ class Claude(Model):
             _request_params["top_p"] = self.top_p
         if self.top_k:
             _request_params["top_k"] = self.top_k
+        if self.betas:
+            _request_params["betas"] = self.betas
+        if self.context_management:
+            _request_params["context_management"] = self.context_management
         if self.mcp_servers:
             _request_params["mcp_servers"] = [
                 {k: v for k, v in asdict(server).items() if v is not None} for server in self.mcp_servers
             ]
+        if self.skills:
+            _request_params["betas"] = self.betas
+            _request_params["container"] = {"skills": self.skills}
         if self.request_params:
             _request_params.update(self.request_params)
 
@@ -173,6 +291,15 @@ class Claude(Model):
             else:
                 request_kwargs["system"] = [{"text": system_message, "type": "text"}]
 
+        # Add code execution tool if skills are enabled
+        if self.skills:
+            code_execution_tool = {"type": "code_execution_20250825", "name": "code_execution"}
+            if tools:
+                # Add code_execution to existing tools, code execution is needed for generating and processing files
+                tools = tools + [code_execution_tool]
+            else:
+                tools = [code_execution_tool]
+
         if tools:
             request_kwargs["tools"] = format_tools_for_model(tools)
 
@@ -199,12 +326,12 @@ class Claude(Model):
             chat_messages, system_message = format_messages(messages)
             request_kwargs = self._prepare_request_kwargs(system_message, tools)
 
-            if self.mcp_servers is not None:
+            if self._has_beta_features():
                 assistant_message.metrics.start_timer()
                 provider_response = self.get_client().beta.messages.create(
                     model=self.id,
                     messages=chat_messages,  # type: ignore
-                    **self.get_request_params(),
+                    **request_kwargs,
                 )
             else:
                 assistant_message.metrics.start_timer()
@@ -266,7 +393,8 @@ class Claude(Model):
             if run_response and run_response.metrics:
                 run_response.metrics.set_time_to_first_token()
 
-            if self.mcp_servers is not None:
+            # Beta features
+            if self._has_beta_features():
                 assistant_message.metrics.start_timer()
                 with self.get_client().beta.messages.stream(
                     model=self.id,
@@ -321,12 +449,13 @@ class Claude(Model):
             chat_messages, system_message = format_messages(messages)
             request_kwargs = self._prepare_request_kwargs(system_message, tools)
 
-            if self.mcp_servers is not None:
+            # Beta features
+            if self._has_beta_features():
                 assistant_message.metrics.start_timer()
                 provider_response = await self.get_async_client().beta.messages.create(
                     model=self.id,
                     messages=chat_messages,  # type: ignore
-                    **self.get_request_params(),
+                    **request_kwargs,
                 )
             else:
                 assistant_message.metrics.start_timer()
@@ -385,7 +514,7 @@ class Claude(Model):
             chat_messages, system_message = format_messages(messages)
             request_kwargs = self._prepare_request_kwargs(system_message, tools)
 
-            if self.mcp_servers is not None:
+            if self._has_beta_features():
                 assistant_message.metrics.start_timer()
                 async with self.get_async_client().beta.messages.stream(
                     model=self.id,
@@ -421,33 +550,13 @@ class Claude(Model):
             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 format_function_call_results(self, messages: List[Message], function_call_results: List[Message]) -> None:
-        """
-        Handle the results of function calls.
-
-        Args:
-            messages (List[Message]): The list of conversation messages.
-            function_call_results (List[Message]): The results of the function calls.
-        """
-        if len(function_call_results) > 0:
-            fc_responses: List = []
-            for _fc_message in function_call_results:
-                fc_responses.append(
-                    {
-                        "type": "tool_result",
-                        "tool_use_id": _fc_message.tool_call_id,
-                        "content": str(_fc_message.content),
-                    }
-                )
-            messages.append(Message(role="user", content=fc_responses))
-
     def get_system_message_for_model(self, tools: Optional[List[Any]] = None) -> Optional[str]:
         if tools is not None and len(tools) > 0:
             tool_call_prompt = "Do not reflect on the quality of the returned search results in your response\n\n"
             return tool_call_prompt
         return None
 
-    def _parse_provider_response(self, response: AnthropicMessage, **kwargs) -> ModelResponse:
+    def _parse_provider_response(self, response: Union[AnthropicMessage, BetaMessage], **kwargs) -> ModelResponse:
         """
         Parse the Claude response into a ModelResponse.
 
@@ -522,6 +631,30 @@ class Claude(Model):
         if response.usage is not None:
             model_response.response_usage = self._get_metrics(response.usage)
 
+        # Capture context management information if present
+        if self.context_management is not None and hasattr(response, "context_management"):
+            if response.context_management is not None:  # type: ignore
+                model_response.provider_data = model_response.provider_data or {}
+                if hasattr(response.context_management, "model_dump"):
+                    model_response.provider_data["context_management"] = response.context_management.model_dump()  # type: ignore
+                else:
+                    model_response.provider_data["context_management"] = response.context_management  # type: ignore
+        # Extract file IDs if skills are enabled
+        if self.skills and response.content:
+            file_ids: List[str] = []
+            for block in response.content:
+                if block.type == "bash_code_execution_tool_result":
+                    if hasattr(block, "content") and hasattr(block.content, "content"):
+                        if isinstance(block.content.content, list):
+                            for output_block in block.content.content:
+                                if hasattr(output_block, "file_id"):
+                                    file_ids.append(output_block.file_id)
+
+            if file_ids:
+                if model_response.provider_data is None:
+                    model_response.provider_data = {}
+                model_response.provider_data["file_ids"] = file_ids
+
         return model_response
 
     def _parse_provider_response_delta(
@@ -532,6 +665,9 @@ class Claude(Model):
             ContentBlockStopEvent,
             MessageStopEvent,
             BetaRawContentBlockDeltaEvent,
+            BetaRawContentBlockStartEvent,
+            ParsedBetaContentBlockStopEvent,
+            ParsedBetaMessageStopEvent,
         ],
     ) -> ModelResponse:
         """
@@ -545,11 +681,11 @@ class Claude(Model):
         """
         model_response = ModelResponse()
 
-        if isinstance(response, ContentBlockStartEvent):
+        if isinstance(response, (ContentBlockStartEvent, BetaRawContentBlockStartEvent)):
             if response.content_block.type == "redacted_reasoning_content":
                 model_response.redacted_reasoning_content = response.content_block.data
 
-        if isinstance(response, ContentBlockDeltaEvent):
+        if isinstance(response, (ContentBlockDeltaEvent, BetaRawContentBlockDeltaEvent)):
             # Handle text content
             if response.delta.type == "text_delta":
                 model_response.content = response.delta.text
@@ -561,7 +697,7 @@ class Claude(Model):
                     "signature": response.delta.signature,
                 }
 
-        elif isinstance(response, ContentBlockStopEvent):
+        elif isinstance(response, (ContentBlockStopEvent, ParsedBetaContentBlockStopEvent)):
             if response.content_block.type == "tool_use":  # type: ignore
                 tool_use = response.content_block  # type: ignore
                 tool_name = tool_use.name
@@ -582,7 +718,7 @@ class Claude(Model):
                 ]
 
         # Capture citations from the final response
-        elif isinstance(response, MessageStopEvent):
+        elif isinstance(response, (MessageStopEvent, ParsedBetaMessageStopEvent)):
             model_response.content = ""
             model_response.citations = Citations(raw=[], urls=[], documents=[])
             for block in response.message.content:  # type: ignore
@@ -600,6 +736,16 @@ class Claude(Model):
                             DocumentCitation(document_title=citation.document_title, cited_text=citation.cited_text)
                         )
 
+            # Capture context management information if present
+            if self.context_management is not None and hasattr(response.message, "context_management"):  # type: ignore
+                context_mgmt = response.message.context_management  # type: ignore
+                if context_mgmt is not None:
+                    model_response.provider_data = model_response.provider_data or {}
+                    if hasattr(context_mgmt, "model_dump"):
+                        model_response.provider_data["context_management"] = context_mgmt.model_dump()
+                    else:
+                        model_response.provider_data["context_management"] = context_mgmt
+
         if hasattr(response, "message") and hasattr(response.message, "usage") and response.message.usage is not None:  # type: ignore
             model_response.response_usage = self._get_metrics(response.message.usage)  # type: ignore
 
@@ -616,7 +762,7 @@ class Claude(Model):
 
         return model_response
 
-    def _get_metrics(self, response_usage: Union[Usage, MessageDeltaUsage]) -> Metrics:
+    def _get_metrics(self, response_usage: Union[Usage, MessageDeltaUsage, BetaUsage]) -> Metrics:
         """
         Parse the given Anthropic-specific usage into an Agno Metrics object.
 
@@ -636,7 +782,7 @@ class Claude(Model):
 
         # Anthropic-specific additional fields
         if response_usage.server_tool_use:
-            metrics.provider_metrics = {"server_tool_use": response_usage.server_tool_use}
+            metrics.provider_metrics = {"server_tool_use": response_usage.server_tool_use.model_dump()}
         if isinstance(response_usage, Usage):
             if response_usage.service_tier:
                 metrics.provider_metrics = metrics.provider_metrics or {}