agno 1.8.1__py3-none-any.whl → 2.0.0rc1__py3-none-any.whl

agno/models/aimlapi/__init__.py

@@ -1,5 +1,5 @@
-from agno.models.aimlapi.aimlapi import AIMLApi
+from agno.models.aimlapi.aimlapi import AIMLAPI
 
 __all__ = [
-    "AIMLApi",
+    "AIMLAPI",
 ]

agno/models/aimlapi/aimlapi.py

@@ -7,22 +7,22 @@ from agno.models.openai.like import OpenAILike
 
 
 @dataclass
-class AIMLApi(OpenAILike):
+class AIMLAPI(OpenAILike):
     """
-    A class for using models hosted on AIMLApi.
+    A class for using models hosted on AIMLAPI.
 
     Attributes:
         id (str): The model id. Defaults to "gpt-4o-mini".
-        name (str): The model name. Defaults to "AIMLApi".
-        provider (str): The provider name. Defaults to "AIMLApi".
+        name (str): The model name. Defaults to "AIMLAPI".
+        provider (str): The provider name. Defaults to "AIMLAPI".
         api_key (Optional[str]): The API key.
         base_url (str): The base URL. Defaults to "https://api.aimlapi.com/v1".
         max_tokens (int): The maximum number of tokens. Defaults to 4096.
     """
 
     id: str = "gpt-4o-mini"
-    name: str = "AIMLApi"
-    provider: str = "AIMLApi"
+    name: str = "AIMLAPI"
+    provider: str = "AIMLAPI"
 
     api_key: Optional[str] = getenv("AIMLAPI_API_KEY")
     base_url: str = "https://api.aimlapi.com/v1"

agno/models/anthropic/claude.py

@@ -9,14 +9,14 @@ from pydantic import BaseModel
 from agno.exceptions import ModelProviderError, ModelRateLimitError
 from agno.models.base import Model
 from agno.models.message import Citations, DocumentCitation, Message, UrlCitation
+from agno.models.metrics import Metrics
 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 MCPServerConfiguration, format_messages
+from agno.utils.models.claude import MCPServerConfiguration, format_messages, format_tools_for_model
 
 try:
-    from anthropic import (
-        Anthropic as AnthropicClient,
-    )
+    from anthropic import Anthropic as AnthropicClient
     from anthropic import (
         APIConnectionError,
         APIStatusError,
@@ -31,8 +31,10 @@ try:
         ContentBlockDeltaEvent,
         ContentBlockStartEvent,
         ContentBlockStopEvent,
+        MessageDeltaUsage,
         # MessageDeltaEvent,  # Currently broken
         MessageStopEvent,
+        Usage,
     )
     from anthropic.types import (
         Message as AnthropicMessage,
@@ -42,11 +44,7 @@ except ImportError as e:
 
 # Import Beta types
 try:
-    from anthropic.types.beta import (
-        BetaMessage,
-        BetaRawContentBlockDeltaEvent,
-        BetaTextDelta,
-    )
+    from anthropic.types.beta import BetaRawContentBlockDeltaEvent, BetaTextDelta
 except ImportError as e:
     raise ImportError(
         "`anthropic` not installed or missing beta components. Please install with `pip install anthropic`"
@@ -176,85 +174,53 @@ class Claude(Model):
                 request_kwargs["system"] = [{"text": system_message, "type": "text"}]
 
         if tools:
-            request_kwargs["tools"] = self._format_tools_for_model(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
 
-    def _format_tools_for_model(self, tools: Optional[List[Dict[str, Any]]] = None) -> Optional[List[Dict[str, Any]]]:
-        """
-        Transforms function definitions into a format accepted by the Anthropic API.
-        """
-        if not tools:
-            return None
-
-        parsed_tools: List[Dict[str, Any]] = []
-        for tool_def in tools:
-            if tool_def.get("type", "") != "function":
-                parsed_tools.append(tool_def)
-                continue
-
-            func_def = tool_def.get("function", {})
-            parameters: Dict[str, Any] = func_def.get("parameters", {})
-            properties: Dict[str, Any] = parameters.get("properties", {})
-            required_params: List[str] = []
-
-            for param_name, param_info in properties.items():
-                param_type = param_info.get("type", "")
-                param_type_list: List[str] = [param_type] if isinstance(param_type, str) else param_type or []
-
-                if "null" not in param_type_list:
-                    required_params.append(param_name)
-
-            input_properties: Dict[str, Dict[str, Union[str, List[str]]]] = {}
-            for param_name, param_info in properties.items():
-                input_properties[param_name] = {
-                    "description": param_info.get("description", ""),
-                }
-                if "type" not in param_info and "anyOf" in param_info:
-                    input_properties[param_name]["anyOf"] = param_info["anyOf"]
-                else:
-                    input_properties[param_name]["type"] = param_info.get("type", "")
-
-            tool = {
-                "name": func_def.get("name") or "",
-                "description": func_def.get("description") or "",
-                "input_schema": {
-                    "type": parameters.get("type", "object"),
-                    "properties": input_properties,
-                    "required": required_params,
-                },
-            }
-            parsed_tools.append(tool)
-        return parsed_tools
-
     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,
-    ) -> Union[AnthropicMessage, BetaMessage]:
+        run_response: Optional[RunOutput] = None,
+    ) -> ModelResponse:
         """
         Send a request to the Anthropic API to generate a response.
         """
         try:
+            if run_response and run_response.metrics:
+                run_response.metrics.set_time_to_first_token()
+
             chat_messages, system_message = format_messages(messages)
             request_kwargs = self._prepare_request_kwargs(system_message, tools)
 
             if self.mcp_servers is not None:
-                return self.get_client().beta.messages.create(
+                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(),
                 )
             else:
-                return self.get_client().messages.create(
+                assistant_message.metrics.start_timer()
+                provider_response = self.get_client().messages.create(
                     model=self.id,
                     messages=chat_messages,  # type: ignore
                     **request_kwargs,
                 )
+
+            assistant_message.metrics.stop_timer()
+
+            # Parse the response into an Agno ModelResponse object
+            model_response = self._parse_provider_response(provider_response, response_format=response_format)  # type: ignore
+
+            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
@@ -273,9 +239,11 @@ class Claude(Model):
     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,
     ) -> Any:
         """
         Stream a response from the Anthropic API.
@@ -295,26 +263,30 @@ class Claude(Model):
         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()
+
             if self.mcp_servers is not None:
-                return (
-                    self.get_client()
-                    .beta.messages.stream(
-                        model=self.id,
-                        messages=chat_messages,  # type: ignore
-                        **request_kwargs,
-                    )
-                    .__enter__()
-                )
+                assistant_message.metrics.start_timer()
+                with self.get_client().beta.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)  # type: ignore
             else:
-                return (
-                    self.get_client()
-                    .messages.stream(
-                        model=self.id,
-                        messages=chat_messages,  # type: ignore
-                        **request_kwargs,
-                    )
-                    .__enter__()
-                )
+                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:  # type: ignore
+                        yield self._parse_provider_response_delta(chunk)  # type: ignore
+
+            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
@@ -333,29 +305,44 @@ class Claude(Model):
     async def ainvoke(
         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,
-    ) -> Union[AnthropicMessage, BetaMessage]:
+        run_response: Optional[RunOutput] = None,
+    ) -> ModelResponse:
         """
         Send an asynchronous request to the Anthropic API to generate a response.
         """
         try:
+            if run_response and run_response.metrics:
+                run_response.metrics.set_time_to_first_token()
+
             chat_messages, system_message = format_messages(messages)
             request_kwargs = self._prepare_request_kwargs(system_message, tools)
 
             if self.mcp_servers is not None:
-                return await self.get_async_client().beta.messages.create(
+                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(),
                 )
             else:
-                return await self.get_async_client().messages.create(
+                assistant_message.metrics.start_timer()
+                provider_response = await self.get_async_client().messages.create(
                     model=self.id,
                     messages=chat_messages,  # type: ignore
                     **request_kwargs,
                 )
+
+            assistant_message.metrics.stop_timer()
+
+            # Parse the response into an Agno ModelResponse object
+            model_response = self._parse_provider_response(provider_response, response_format=response_format)  # type: ignore
+
+            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
@@ -374,44 +361,51 @@ class Claude(Model):
     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,
-    ) -> AsyncIterator[Any]:
+        run_response: Optional[RunOutput] = None,
+    ) -> AsyncIterator[ModelResponse]:
         """
         Stream an asynchronous 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.
-
+            AsyncIterator[ModelResponse]: An async iterator of processed model responses.
         Raises:
             APIConnectionError: If there are network connectivity issues
             RateLimitError: If the API rate limit is exceeded
             APIStatusError: For other API-related errors
         """
         try:
+            if run_response and run_response.metrics:
+                run_response.metrics.set_time_to_first_token()
+
             chat_messages, system_message = format_messages(messages)
             request_kwargs = self._prepare_request_kwargs(system_message, tools)
 
             if self.mcp_servers is not None:
+                assistant_message.metrics.start_timer()
                 async with self.get_async_client().beta.messages.stream(
                     model=self.id,
                     messages=chat_messages,  # type: ignore
                     **request_kwargs,
                 ) as stream:
                     async for chunk in stream:
-                        yield chunk
+                        yield self._parse_provider_response_delta(chunk)  # type: ignore
             else:
+                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:  # type: ignore
-                        yield chunk
+                        yield self._parse_provider_response_delta(chunk)  # type: ignore
+
+            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
@@ -453,7 +447,7 @@ class Claude(Model):
             return tool_call_prompt
         return None
 
-    def parse_provider_response(self, response: AnthropicMessage, **kwargs) -> ModelResponse:
+    def _parse_provider_response(self, response: AnthropicMessage, **kwargs) -> ModelResponse:
         """
         Parse the Claude response into a ModelResponse.
 
@@ -496,12 +490,12 @@ class Claude(Model):
                                     )
                                 )
                 elif block.type == "thinking":
-                    model_response.thinking = block.thinking
+                    model_response.reasoning_content = block.thinking
                     model_response.provider_data = {
                         "signature": block.signature,
                     }
                 elif block.type == "redacted_thinking":
-                    model_response.redacted_thinking = block.data
+                    model_response.redacted_reasoning_content = block.data
 
         # Extract tool calls from the response
         if response.stop_reason == "tool_use":
@@ -515,6 +509,7 @@ class Claude(Model):
                         function_def["arguments"] = json.dumps(tool_input)
 
                     model_response.extra = model_response.extra or {}
+
                     model_response.tool_calls.append(
                         {
                             "id": block.id,
@@ -525,23 +520,19 @@ class Claude(Model):
 
         # Add usage metrics
         if response.usage is not None:
-            usage_dict = {
-                "input_tokens": response.usage.input_tokens,
-                "output_tokens": response.usage.output_tokens,
-            }
-
-            if hasattr(response.usage, "cache_creation_input_tokens") and response.usage.cache_creation_input_tokens:
-                usage_dict["cache_write_tokens"] = response.usage.cache_creation_input_tokens
-
-            if hasattr(response.usage, "cache_read_input_tokens") and response.usage.cache_read_input_tokens:
-                usage_dict["cached_tokens"] = response.usage.cache_read_input_tokens
-
-            model_response.response_usage = usage_dict
+            model_response.response_usage = self._get_metrics(response.usage)
 
         return model_response
 
-    def parse_provider_response_delta(
-        self, response: Union[ContentBlockStartEvent, ContentBlockDeltaEvent, ContentBlockStopEvent, MessageStopEvent]
+    def _parse_provider_response_delta(
+        self,
+        response: Union[
+            ContentBlockStartEvent,
+            ContentBlockDeltaEvent,
+            ContentBlockStopEvent,
+            MessageStopEvent,
+            BetaRawContentBlockDeltaEvent,
+        ],
     ) -> ModelResponse:
         """
         Parse the Claude streaming response into ModelProviderResponse objects.
@@ -553,9 +544,10 @@ class Claude(Model):
             ModelResponse: Iterator of parsed response data
         """
         model_response = ModelResponse()
+
         if isinstance(response, ContentBlockStartEvent):
-            if response.content_block.type == "redacted_thinking":
-                model_response.redacted_thinking = response.content_block.data
+            if response.content_block.type == "redacted_reasoning_content":
+                model_response.redacted_reasoning_content = response.content_block.data
 
         if isinstance(response, ContentBlockDeltaEvent):
             # Handle text content
@@ -563,23 +555,14 @@ class Claude(Model):
                 model_response.content = response.delta.text
             # Handle thinking content
             elif response.delta.type == "thinking_delta":
-                model_response.thinking = response.delta.thinking
+                model_response.reasoning_content = response.delta.thinking
             elif response.delta.type == "signature_delta":
                 model_response.provider_data = {
                     "signature": response.delta.signature,
                 }
 
         elif isinstance(response, ContentBlockStopEvent):
-            # Handle completed thinking content
-            if response.content_block.type == "thinking":  # type: ignore
-                model_response.thinking = response.content_block.thinking  # type: ignore
-                # Store signature if available
-                if hasattr(response.content_block, "signature"):  # type: ignore
-                    model_response.provider_data = {
-                        "signature": response.content_block.signature,  # type: ignore
-                    }
-            # Handle tool calls
-            elif response.content_block.type == "tool_use":  # type: ignore
+            if response.content_block.type == "tool_use":  # type: ignore
                 tool_use = response.content_block  # type: ignore
                 tool_name = tool_use.name
                 tool_input = tool_use.input
@@ -617,19 +600,8 @@ class Claude(Model):
                             DocumentCitation(document_title=citation.document_title, cited_text=citation.cited_text)
                         )
 
-        if hasattr(response, "usage") and response.usage is not None:
-            usage_dict = {
-                "input_tokens": response.usage.input_tokens or 0,
-                "output_tokens": response.usage.output_tokens or 0,
-            }
-
-            if hasattr(response.usage, "cache_creation_input_tokens") and response.usage.cache_creation_input_tokens:
-                usage_dict["cache_write_tokens"] = response.usage.cache_creation_input_tokens
-
-            if hasattr(response.usage, "cache_read_input_tokens") and response.usage.cache_read_input_tokens:
-                usage_dict["cached_tokens"] = response.usage.cache_read_input_tokens
-
-            model_response.response_usage = usage_dict
+        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
 
         # Capture the Beta response
         try:
@@ -643,3 +615,31 @@ class Claude(Model):
             log_error(f"Error parsing Beta response: {e}")
 
         return model_response
+
+    def _get_metrics(self, response_usage: Union[Usage, MessageDeltaUsage]) -> Metrics:
+        """
+        Parse the given Anthropic-specific usage into an Agno Metrics object.
+
+        Args:
+            response_usage: Usage data from Anthropic
+
+        Returns:
+            Metrics: Parsed metrics data
+        """
+        metrics = Metrics()
+
+        metrics.input_tokens = response_usage.input_tokens or 0
+        metrics.output_tokens = response_usage.output_tokens or 0
+        metrics.total_tokens = metrics.input_tokens + metrics.output_tokens
+        metrics.cache_read_tokens = response_usage.cache_read_input_tokens or 0
+        metrics.cache_write_tokens = response_usage.cache_creation_input_tokens or 0
+
+        # Anthropic-specific additional fields
+        if response_usage.server_tool_use:
+            metrics.provider_metrics = {"server_tool_use": response_usage.server_tool_use}
+        if isinstance(response_usage, Usage):
+            if response_usage.service_tier:
+                metrics.provider_metrics = metrics.provider_metrics or {}
+                metrics.provider_metrics["service_tier"] = response_usage.service_tier
+
+        return metrics