agno 2.2.13__py3-none-any.whl

agno/models/anthropic/claude.py

@@ -0,0 +1,757 @@
+import json
+from collections.abc import AsyncIterator
+from dataclasses import asdict, dataclass
+from os import getenv
+from typing import Any, Dict, List, Optional, Type, Union
+
+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, format_tools_for_model
+
+try:
+    from anthropic import Anthropic as AnthropicClient
+    from anthropic import (
+        APIConnectionError,
+        APIStatusError,
+        RateLimitError,
+    )
+    from anthropic import (
+        AsyncAnthropic as AsyncAnthropicClient,
+    )
+    from anthropic.types import (
+        CitationPageLocation,
+        CitationsWebSearchResultLocation,
+        ContentBlockDeltaEvent,
+        ContentBlockStartEvent,
+        ContentBlockStopEvent,
+        MessageDeltaUsage,
+        # MessageDeltaEvent,  # Currently broken
+        MessageStopEvent,
+        Usage,
+    )
+    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`"
+    ) from e
+
+
+@dataclass
+class Claude(Model):
+    """
+    A class representing Anthropic Claude model.
+
+    For more information, see: https://docs.anthropic.com/en/api/messages
+    """
+
+    # 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] = 8192
+    thinking: Optional[Dict[str, Any]] = None
+    temperature: Optional[float] = None
+    stop_sequences: Optional[List[str]] = None
+    top_p: Optional[float] = None
+    top_k: Optional[int] = None
+    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
+    client_params: Optional[Dict[str, Any]] = None
+
+    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] = {}
+
+        self.api_key = self.api_key or getenv("ANTHROPIC_API_KEY")
+        if not self.api_key:
+            log_error("ANTHROPIC_API_KEY not set. Please set the ANTHROPIC_API_KEY environment variable.")
+
+        # 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:
+            client_params.update(self.client_params)
+        if self.default_headers is not None:
+            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.
+        """
+        if self.client and not self.client.is_closed():
+            return self.client
+
+        _client_params = self._get_client_params()
+        self.client = AnthropicClient(**_client_params)
+        return self.client
+
+    def get_async_client(self) -> AsyncAnthropicClient:
+        """
+        Returns an instance of the async Anthropic client.
+        """
+        if self.async_client and not self.async_client.is_closed():
+            return self.async_client
+
+        _client_params = self._get_client_params()
+        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
+        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.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)
+
+        return _request_params
+
+    def _prepare_request_kwargs(
+        self, system_message: str, tools: Optional[List[Dict[str, Any]]] = None
+    ) -> Dict[str, Any]:
+        """
+        Prepare the request keyword arguments for the API call.
+
+        Args:
+            system_message (str): The concatenated system messages.
+
+        Returns:
+            Dict[str, Any]: The request keyword arguments.
+        """
+        request_kwargs = self.get_request_params().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"}]
+
+        # 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)
+
+        if request_kwargs:
+            log_debug(f"Calling {self.provider} with request parameters: {request_kwargs}", log_level=2)
+        return request_kwargs
+
+    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:
+            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._has_beta_features():
+                assistant_message.metrics.start_timer()
+                provider_response = self.get_client().beta.messages.create(
+                    model=self.id,
+                    messages=chat_messages,  # type: ignore
+                    **request_kwargs,
+                )
+            else:
+                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
+        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,
+    ) -> Any:
+        """
+        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()
+
+            # Beta features
+            if self._has_beta_features():
+                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:
+                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
+        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(
+        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 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)
+
+            # 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
+                    **request_kwargs,
+                )
+            else:
+                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
+        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]:
+        """
+        Stream an asynchronous response from the Anthropic API.
+        Args:
+            messages (List[Message]): A list of messages to send to the model.
+        Returns:
+            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._has_beta_features():
+                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 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 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
+        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 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: Union[AnthropicMessage, BetaMessage], **kwargs) -> ModelResponse:
+        """
+        Parse the Claude response into a ModelResponse.
+
+        Args:
+            response: Raw response from Anthropic
+
+        Returns:
+            ModelResponse: Parsed response data
+        """
+        model_response = ModelResponse()
+
+        # Add role (Claude always uses 'assistant')
+        model_response.role = response.role or "assistant"
+
+        if response.content:
+            for block in response.content:
+                if block.type == "text":
+                    if model_response.content is None:
+                        model_response.content = block.text
+                    else:
+                        model_response.content += block.text
+
+                    # Capture citations from the response
+                    if block.citations is not None:
+                        if model_response.citations is None:
+                            model_response.citations = Citations(raw=[], urls=[], documents=[])
+                        for citation in block.citations:
+                            model_response.citations.raw.append(citation.model_dump())  # type: ignore
+                            # Web search citations
+                            if isinstance(citation, CitationsWebSearchResultLocation):
+                                model_response.citations.urls.append(  # type: ignore
+                                    UrlCitation(url=citation.url, title=citation.cited_text)
+                                )
+                            # Document citations
+                            elif isinstance(citation, CitationPageLocation):
+                                model_response.citations.documents.append(  # type: ignore
+                                    DocumentCitation(
+                                        document_title=citation.document_title,
+                                        cited_text=citation.cited_text,
+                                    )
+                                )
+                elif block.type == "thinking":
+                    model_response.reasoning_content = block.thinking
+                    model_response.provider_data = {
+                        "signature": block.signature,
+                    }
+                elif block.type == "redacted_thinking":
+                    model_response.redacted_reasoning_content = block.data
+
+        # Extract tool calls from the response
+        if response.stop_reason == "tool_use":
+            for block in response.content:
+                if block.type == "tool_use":
+                    tool_name = block.name
+                    tool_input = block.input
+
+                    function_def = {"name": tool_name}
+                    if tool_input:
+                        function_def["arguments"] = json.dumps(tool_input)
+
+                    model_response.extra = model_response.extra or {}
+
+                    model_response.tool_calls.append(
+                        {
+                            "id": block.id,
+                            "type": "function",
+                            "function": function_def,
+                        }
+                    )
+
+        # Add usage metrics
+        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(
+        self,
+        response: Union[
+            ContentBlockStartEvent,
+            ContentBlockDeltaEvent,
+            ContentBlockStopEvent,
+            MessageStopEvent,
+            BetaRawContentBlockDeltaEvent,
+        ],
+    ) -> ModelResponse:
+        """
+        Parse the Claude streaming response into ModelProviderResponse objects.
+
+        Args:
+            response: Raw response chunk from Anthropic
+
+        Returns:
+            ModelResponse: Iterator of parsed response data
+        """
+        model_response = ModelResponse()
+
+        if isinstance(response, ContentBlockStartEvent):
+            if response.content_block.type == "redacted_reasoning_content":
+                model_response.redacted_reasoning_content = response.content_block.data
+
+        if isinstance(response, ContentBlockDeltaEvent):
+            # Handle text content
+            if response.delta.type == "text_delta":
+                model_response.content = response.delta.text
+            # Handle thinking content
+            elif response.delta.type == "thinking_delta":
+                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):
+            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
+
+                function_def = {"name": tool_name}
+                if tool_input:
+                    function_def["arguments"] = json.dumps(tool_input)
+
+                model_response.extra = model_response.extra or {}
+
+                model_response.tool_calls = [
+                    {
+                        "id": tool_use.id,
+                        "type": "function",
+                        "function": function_def,
+                    }
+                ]
+
+        # Capture citations from the final response
+        elif isinstance(response, MessageStopEvent):
+            model_response.content = ""
+            model_response.citations = Citations(raw=[], urls=[], documents=[])
+            for block in response.message.content:  # type: ignore
+                citations = getattr(block, "citations", None)
+                if not citations:
+                    continue
+                for citation in citations:
+                    model_response.citations.raw.append(citation.model_dump())  # type: ignore
+                    # Web search citations
+                    if isinstance(citation, CitationsWebSearchResultLocation):
+                        model_response.citations.urls.append(UrlCitation(url=citation.url, title=citation.cited_text))  # type: ignore
+                    # Document citations
+                    elif isinstance(citation, CitationPageLocation):
+                        model_response.citations.documents.append(  # type: ignore
+                            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
+
+        # Capture the Beta response
+        try:
+            if (
+                isinstance(response, BetaRawContentBlockDeltaEvent)
+                and isinstance(response.delta, BetaTextDelta)
+                and response.delta.text is not None
+            ):
+                model_response.content = response.delta.text
+        except Exception as e:
+            log_error(f"Error parsing Beta response: {e}")
+
+        return model_response
+
+    def _get_metrics(self, response_usage: Union[Usage, MessageDeltaUsage, BetaUsage]) -> 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.model_dump()}
+        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