agno 2.2.13__py3-none-any.whl → 2.4.3__py3-none-any.whl

agno/models/anthropic/claude.py

@@ -4,7 +4,8 @@ from dataclasses import asdict, dataclass
 from os import getenv
 from typing import Any, Dict, List, Optional, Type, Union
 
-from pydantic import BaseModel
+import httpx
+from pydantic import BaseModel, ValidationError
 
 from agno.exceptions import ModelProviderError, ModelRateLimitError
 from agno.models.base import Model
@@ -12,8 +13,11 @@ 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.tools.function import Function
+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
+from agno.utils.tokens import count_schema_tokens
 
 try:
     from anthropic import Anthropic as AnthropicClient
@@ -25,6 +29,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,6 +48,7 @@ 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
 
@@ -72,6 +82,30 @@ class Claude(Model):
         "claude-3-5-haiku-latest",
     }
 
+    # Models that DO NOT support native structured outputs
+    # All future models are assumed to support structured outputs
+    NON_STRUCTURED_OUTPUT_MODELS = {
+        # Claude 3.x family (all versions)
+        "claude-3-opus-20240229",
+        "claude-3-sonnet-20240229",
+        "claude-3-haiku-20240307",
+        "claude-3-opus",
+        "claude-3-sonnet",
+        "claude-3-haiku",
+        # Claude 3.5 family (all versions except Sonnet 4.5)
+        "claude-3-5-sonnet-20240620",
+        "claude-3-5-sonnet-20241022",
+        "claude-3-5-sonnet",
+        "claude-3-5-haiku-20241022",
+        "claude-3-5-haiku-latest",
+        "claude-3-5-haiku",
+        # Claude Sonnet 4.x family (versions before 4.5)
+        "claude-sonnet-4-20250514",
+        "claude-sonnet-4",
+        # Claude Opus 4.x family (versions before 4.1 and 4.5)
+        # (Add any Opus 4.x models released before 4.1/4.5 if they exist)
+    }
+
     id: str = "claude-sonnet-4-5-20250929"
     name: str = "Claude"
     provider: str = "Anthropic"
@@ -97,8 +131,10 @@ class Claude(Model):
 
     # Client parameters
     api_key: Optional[str] = None
+    auth_token: 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
 
     client: Optional[AnthropicClient] = None
@@ -109,6 +145,9 @@ class Claude(Model):
         # Validate thinking support immediately at model creation
         if self.thinking:
             self._validate_thinking_support()
+        # Set structured outputs capability flag for supported models
+        if self._supports_structured_outputs():
+            self.supports_native_structured_outputs = True
         # Set up skills configuration if skills are enabled
         if self.skills:
             self._setup_skills_configuration()
@@ -117,11 +156,15 @@ class Claude(Model):
         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.")
+        self.auth_token = self.auth_token or getenv("ANTHROPIC_AUTH_TOKEN")
+        if not (self.api_key or self.auth_token):
+            log_error(
+                "ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN not set. Please set the ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN environment variable."
+            )
 
         # Add API key to client parameters
         client_params["api_key"] = self.api_key
+        client_params["auth_token"] = self.auth_token
         if self.timeout is not None:
             client_params["timeout"] = self.timeout
 
@@ -132,36 +175,63 @@ 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 _supports_structured_outputs(self) -> bool:
+        """
+        Check if the current model supports native structured outputs.
 
-    def get_client(self) -> AnthropicClient:
+        Returns:
+            bool: True if model supports structured outputs
         """
-        Returns an instance of the Anthropic client.
+        # If model is in blacklist, it doesn't support structured outputs
+        if self.id in self.NON_STRUCTURED_OUTPUT_MODELS:
+            return False
+
+        # Check for legacy model patterns which don't support structured outputs
+        if self.id.startswith("claude-3-"):
+            return False
+        if self.id.startswith("claude-sonnet-4-") and not self.id.startswith("claude-sonnet-4-5"):
+            return False
+        if self.id.startswith("claude-opus-4-") and not (
+            self.id.startswith("claude-opus-4-1") or self.id.startswith("claude-opus-4-5")
+        ):
+            return False
+
+        return True
+
+    def _using_structured_outputs(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> bool:
         """
-        if self.client and not self.client.is_closed():
-            return self.client
+        Check if structured outputs are being used in this request.
 
-        _client_params = self._get_client_params()
-        self.client = AnthropicClient(**_client_params)
-        return self.client
+        Args:
+            response_format: Response format parameter
+            tools: Tools list to check for strict mode
 
-    def get_async_client(self) -> AsyncAnthropicClient:
-        """
-        Returns an instance of the async Anthropic client.
+        Returns:
+            bool: True if structured outputs are in use
         """
-        if self.async_client and not self.async_client.is_closed():
-            return self.async_client
+        # Check for output_format usage
+        if response_format is not None:
+            if self._supports_structured_outputs():
+                return True
+            else:
+                log_warning(
+                    f"Model '{self.id}' does not support structured outputs. "
+                    "Structured output features will not be available for this model."
+                )
 
-        _client_params = self._get_client_params()
-        self.async_client = AsyncAnthropicClient(**_client_params)
-        return self.async_client
+        # Check for strict tools
+        if tools:
+            for tool in tools:
+                if tool.get("type") == "function":
+                    func_def = tool.get("function", {})
+                    if func_def.get("strict") is True:
+                        return True
+
+        return False
 
     def _validate_thinking_support(self) -> None:
         """
@@ -199,7 +269,214 @@ class Claude(Model):
                 if beta not in self.betas:
                     self.betas.append(beta)
 
-    def get_request_params(self) -> Dict[str, Any]:
+    def _ensure_additional_properties_false(self, schema: Dict[str, Any]) -> None:
+        """
+        Recursively ensure all object types have additionalProperties: false.
+        """
+        if isinstance(schema, dict):
+            if schema.get("type") == "object":
+                schema["additionalProperties"] = False
+
+            # Recursively process nested schemas
+            for key, value in schema.items():
+                if key in ["properties", "items", "allOf", "anyOf", "oneOf"]:
+                    if isinstance(value, dict):
+                        self._ensure_additional_properties_false(value)
+                    elif isinstance(value, list):
+                        for item in value:
+                            if isinstance(item, dict):
+                                self._ensure_additional_properties_false(item)
+
+    def _build_output_format(self, response_format: Optional[Union[Dict, Type[BaseModel]]]) -> Optional[Dict[str, Any]]:
+        """
+        Build Anthropic output_format parameter from response_format.
+
+        Args:
+            response_format: Pydantic model or dict format
+
+        Returns:
+            Dict with output_format structure or None
+        """
+        if response_format is None:
+            return None
+
+        if not self._supports_structured_outputs():
+            return None
+
+        # Handle Pydantic BaseModel
+        if isinstance(response_format, type) and issubclass(response_format, BaseModel):
+            try:
+                # Try to use Anthropic SDK's transform_schema helper if available
+                from anthropic import transform_schema
+
+                schema = transform_schema(response_format.model_json_schema())
+            except (ImportError, AttributeError):
+                # Fallback to direct schema conversion
+                schema = response_format.model_json_schema()
+                # Ensure additionalProperties is False
+                if isinstance(schema, dict):
+                    if "additionalProperties" not in schema:
+                        schema["additionalProperties"] = False
+                    # Recursively ensure all object types have additionalProperties: false
+                    self._ensure_additional_properties_false(schema)
+
+            return {"type": "json_schema", "schema": schema}
+
+        # Handle dict format
+        elif isinstance(response_format, dict):
+            # Claude only supports json_schema, not json_object
+            if response_format.get("type") == "json_object":
+                return None
+            return response_format
+
+        return None
+
+    def _validate_structured_outputs_usage(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> None:
+        """
+        Validate that structured outputs are only used with supported models.
+
+        Raises:
+            ValueError: If structured outputs are used with unsupported model
+        """
+        if not self._using_structured_outputs(response_format, tools):
+            return
+
+        if not self._supports_structured_outputs():
+            raise ValueError(f"Model '{self.id}' does not support structured outputs.\n\n")
+
+    def _has_beta_features(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> 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
+            or self._using_structured_outputs(response_format, tools)
+        )
+
+    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()
+        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
+
+    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()
+        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 to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the model to a dictionary.
+
+        Returns:
+            Dict[str, Any]: The dictionary representation of the model.
+        """
+        model_dict = super().to_dict()
+        model_dict.update(
+            {
+                "max_tokens": self.max_tokens,
+                "thinking": self.thinking,
+                "temperature": self.temperature,
+                "stop_sequences": self.stop_sequences,
+                "top_p": self.top_p,
+                "top_k": self.top_k,
+                "cache_system_prompt": self.cache_system_prompt,
+                "extended_cache_time": self.extended_cache_time,
+                "betas": self.betas,
+            }
+        )
+        cleaned_dict = {k: v for k, v in model_dict.items() if v is not None}
+        return cleaned_dict
+
+    def count_tokens(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Union[Function, Dict[str, Any]]]] = None,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+    ) -> int:
+        anthropic_messages, system_prompt = format_messages(messages, compress_tool_results=True)
+        anthropic_tools = None
+        if tools:
+            formatted_tools = self._format_tools(tools)
+            anthropic_tools = format_tools_for_model(formatted_tools)
+
+        kwargs: Dict[str, Any] = {"messages": anthropic_messages, "model": self.id}
+        if system_prompt:
+            kwargs["system"] = system_prompt
+        if anthropic_tools:
+            kwargs["tools"] = anthropic_tools
+
+        response = self.get_client().messages.count_tokens(**kwargs)
+        return response.input_tokens + count_schema_tokens(response_format, self.id)
+
+    async def acount_tokens(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Union[Function, Dict[str, Any]]]] = None,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+    ) -> int:
+        anthropic_messages, system_prompt = format_messages(messages, compress_tool_results=True)
+        anthropic_tools = None
+        if tools:
+            formatted_tools = self._format_tools(tools)
+            anthropic_tools = format_tools_for_model(formatted_tools)
+
+        kwargs: Dict[str, Any] = {"messages": anthropic_messages, "model": self.id}
+        if system_prompt:
+            kwargs["system"] = system_prompt
+        if anthropic_tools:
+            kwargs["tools"] = anthropic_tools
+
+        response = await self.get_async_client().messages.count_tokens(**kwargs)
+        return response.input_tokens + count_schema_tokens(response_format, self.id)
+
+    def get_request_params(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
         """
         Generate keyword arguments for API requests.
         """
@@ -220,8 +497,20 @@ 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
+
+        # Build betas list - include existing betas and add new one if needed
+        betas_list = list(self.betas) if self.betas else []
+
+        # Add structured outputs beta header if using structured outputs
+        if self._using_structured_outputs(response_format, tools):
+            beta_header = "structured-outputs-2025-11-13"
+            if beta_header not in betas_list:
+                betas_list.append(beta_header)
+
+        # Include betas if any are present
+        if betas_list:
+            _request_params["betas"] = betas_list
+
         if self.context_management:
             _request_params["context_management"] = self.context_management
         if self.mcp_servers:
@@ -229,7 +518,6 @@ class Claude(Model):
                 {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)
@@ -237,18 +525,27 @@ class Claude(Model):
         return _request_params
 
     def _prepare_request_kwargs(
-        self, system_message: str, tools: Optional[List[Dict[str, Any]]] = None
+        self,
+        system_message: str,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
     ) -> Dict[str, Any]:
         """
         Prepare the request keyword arguments for the API call.
 
         Args:
             system_message (str): The concatenated system messages.
+            tools: Optional list of tools
+            response_format: Optional response format (Pydantic model or dict)
 
         Returns:
             Dict[str, Any]: The request keyword arguments.
         """
-        request_kwargs = self.get_request_params().copy()
+        # Validate structured outputs usage
+        self._validate_structured_outputs_usage(response_format, tools)
+
+        # 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 = (
@@ -269,9 +566,15 @@ class Claude(Model):
             else:
                 tools = [code_execution_tool]
 
+        # Format tools (this will handle strict mode)
         if tools:
             request_kwargs["tools"] = format_tools_for_model(tools)
 
+        # Build output_format if response_format is provided
+        output_format = self._build_output_format(response_format)
+        if output_format:
+            request_kwargs["output_format"] = output_format
+
         if request_kwargs:
             log_debug(f"Calling {self.provider} with request parameters: {request_kwargs}", log_level=2)
         return request_kwargs
@@ -284,6 +587,7 @@ class Claude(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> ModelResponse:
         """
         Send a request to the Anthropic API to generate a response.
@@ -292,10 +596,10 @@ class Claude(Model):
             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)
+            chat_messages, system_message = format_messages(messages, compress_tool_results=compress_tool_results)
+            request_kwargs = self._prepare_request_kwargs(system_message, tools=tools, response_format=response_format)
 
-            if self._has_beta_features():
+            if self._has_beta_features(response_format=response_format, tools=tools):
                 assistant_message.metrics.start_timer()
                 provider_response = self.get_client().beta.messages.create(
                     model=self.id,
@@ -340,6 +644,7 @@ class Claude(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> Any:
         """
         Stream a response from the Anthropic API.
@@ -355,15 +660,15 @@ class Claude(Model):
             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)
+        chat_messages, system_message = format_messages(messages, compress_tool_results=compress_tool_results)
+        request_kwargs = self._prepare_request_kwargs(system_message, tools=tools, response_format=response_format)
 
         try:
             if run_response and run_response.metrics:
                 run_response.metrics.set_time_to_first_token()
 
             # Beta features
-            if self._has_beta_features():
+            if self._has_beta_features(response_format=response_format, tools=tools):
                 assistant_message.metrics.start_timer()
                 with self.get_client().beta.messages.stream(
                     model=self.id,
@@ -371,7 +676,7 @@ class Claude(Model):
                     **request_kwargs,
                 ) as stream:
                     for chunk in stream:
-                        yield self._parse_provider_response_delta(chunk)  # type: ignore
+                        yield self._parse_provider_response_delta(chunk, response_format=response_format)  # type: ignore
             else:
                 assistant_message.metrics.start_timer()
                 with self.get_client().messages.stream(
@@ -380,7 +685,7 @@ class Claude(Model):
                     **request_kwargs,
                 ) as stream:
                     for chunk in stream:  # type: ignore
-                        yield self._parse_provider_response_delta(chunk)  # type: ignore
+                        yield self._parse_provider_response_delta(chunk, response_format=response_format)  # type: ignore
 
             assistant_message.metrics.stop_timer()
 
@@ -407,6 +712,7 @@ class Claude(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> ModelResponse:
         """
         Send an asynchronous request to the Anthropic API to generate a response.
@@ -415,11 +721,11 @@ class Claude(Model):
             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)
+            chat_messages, system_message = format_messages(messages, compress_tool_results=compress_tool_results)
+            request_kwargs = self._prepare_request_kwargs(system_message, tools=tools, response_format=response_format)
 
             # Beta features
-            if self._has_beta_features():
+            if self._has_beta_features(response_format=response_format, tools=tools):
                 assistant_message.metrics.start_timer()
                 provider_response = await self.get_async_client().beta.messages.create(
                     model=self.id,
@@ -464,6 +770,7 @@ class Claude(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> AsyncIterator[ModelResponse]:
         """
         Stream an asynchronous response from the Anthropic API.
@@ -480,10 +787,10 @@ class Claude(Model):
             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)
+            chat_messages, system_message = format_messages(messages, compress_tool_results=compress_tool_results)
+            request_kwargs = self._prepare_request_kwargs(system_message, tools=tools, response_format=response_format)
 
-            if self._has_beta_features():
+            if self._has_beta_features(response_format=response_format, tools=tools):
                 assistant_message.metrics.start_timer()
                 async with self.get_async_client().beta.messages.stream(
                     model=self.id,
@@ -491,7 +798,7 @@ class Claude(Model):
                     **request_kwargs,
                 ) as stream:
                     async for chunk in stream:
-                        yield self._parse_provider_response_delta(chunk)  # type: ignore
+                        yield self._parse_provider_response_delta(chunk, response_format=response_format)  # type: ignore
             else:
                 assistant_message.metrics.start_timer()
                 async with self.get_async_client().messages.stream(
@@ -500,7 +807,7 @@ class Claude(Model):
                     **request_kwargs,
                 ) as stream:
                     async for chunk in stream:  # type: ignore
-                        yield self._parse_provider_response_delta(chunk)  # type: ignore
+                        yield self._parse_provider_response_delta(chunk, response_format=response_format)  # type: ignore
 
             assistant_message.metrics.stop_timer()
 
@@ -525,12 +832,18 @@ class Claude(Model):
             return tool_call_prompt
         return None
 
-    def _parse_provider_response(self, response: Union[AnthropicMessage, BetaMessage], **kwargs) -> ModelResponse:
+    def _parse_provider_response(
+        self,
+        response: Union[AnthropicMessage, BetaMessage],
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        **kwargs,
+    ) -> ModelResponse:
         """
         Parse the Claude response into a ModelResponse.
 
         Args:
             response: Raw response from Anthropic
+            response_format: Optional response format for structured output parsing
 
         Returns:
             ModelResponse: Parsed response data
@@ -543,10 +856,32 @@ class Claude(Model):
         if response.content:
             for block in response.content:
                 if block.type == "text":
+                    text_content = block.text
+
                     if model_response.content is None:
-                        model_response.content = block.text
+                        model_response.content = text_content
                     else:
-                        model_response.content += block.text
+                        model_response.content += text_content
+
+                    # Handle structured outputs (JSON outputs)
+                    if (
+                        response_format is not None
+                        and isinstance(response_format, type)
+                        and issubclass(response_format, BaseModel)
+                    ):
+                        if text_content:
+                            try:
+                                # Parse JSON from text content
+                                parsed_data = json.loads(text_content)
+                                # Validate against Pydantic model
+                                model_response.parsed = response_format.model_validate(parsed_data)
+                                log_debug(f"Successfully parsed structured output: {model_response.parsed}")
+                            except json.JSONDecodeError as e:
+                                log_warning(f"Failed to parse JSON from structured output: {e}")
+                            except ValidationError as e:
+                                log_warning(f"Failed to validate structured output against schema: {e}")
+                            except Exception as e:
+                                log_warning(f"Unexpected error parsing structured output: {e}")
 
                     # Capture citations from the response
                     if block.citations is not None:
@@ -634,24 +969,29 @@ class Claude(Model):
             ContentBlockStopEvent,
             MessageStopEvent,
             BetaRawContentBlockDeltaEvent,
+            BetaRawContentBlockStartEvent,
+            ParsedBetaContentBlockStopEvent,
+            ParsedBetaMessageStopEvent,
         ],
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
     ) -> ModelResponse:
         """
         Parse the Claude streaming response into ModelProviderResponse objects.
 
         Args:
             response: Raw response chunk from Anthropic
+            response_format: Optional response format for structured output parsing
 
         Returns:
             ModelResponse: Iterator of parsed response data
         """
         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
@@ -663,11 +1003,11 @@ 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
-                tool_input = tool_use.input
+                tool_name = tool_use.name  # type: ignore
+                tool_input = tool_use.input  # type: ignore
 
                 function_def = {"name": tool_name}
                 if tool_input:
@@ -677,17 +1017,30 @@ class Claude(Model):
 
                 model_response.tool_calls = [
                     {
-                        "id": tool_use.id,
+                        "id": tool_use.id,  # type: ignore
                         "type": "function",
                         "function": function_def,
                     }
                 ]
 
-        # Capture citations from the final response
-        elif isinstance(response, MessageStopEvent):
+        # Capture citations from the final response and handle structured outputs
+        elif isinstance(response, (MessageStopEvent, ParsedBetaMessageStopEvent)):
+            # In streaming mode, content has already been emitted via ContentBlockDeltaEvent chunks
+            # Setting content here would cause duplication since _populate_stream_data accumulates with +=
+            # Keep content empty to avoid duplication
             model_response.content = ""
             model_response.citations = Citations(raw=[], urls=[], documents=[])
+
+            # Accumulate text content for structured output parsing (but don't set model_response.content)
+            # The text was already streamed via ContentBlockDeltaEvent chunks
+            accumulated_text = ""
+
             for block in response.message.content:  # type: ignore
+                # Handle text blocks for structured output parsing
+                if block.type == "text":
+                    accumulated_text += block.text  # type: ignore
+
+                # Handle citations
                 citations = getattr(block, "citations", None)
                 if not citations:
                     continue
@@ -702,6 +1055,28 @@ class Claude(Model):
                             DocumentCitation(document_title=citation.document_title, cited_text=citation.cited_text)
                         )
 
+            # Handle structured outputs (JSON outputs) from accumulated text
+            # Note: We parse from accumulated_text but don't set model_response.content to avoid duplication
+            # The content was already streamed via ContentBlockDeltaEvent chunks
+            if (
+                response_format is not None
+                and isinstance(response_format, type)
+                and issubclass(response_format, BaseModel)
+            ):
+                if accumulated_text:
+                    try:
+                        # Parse JSON from accumulated text content
+                        parsed_data = json.loads(accumulated_text)
+                        # Validate against Pydantic model
+                        model_response.parsed = response_format.model_validate(parsed_data)
+                        log_debug(f"Successfully parsed structured output from stream: {model_response.parsed}")
+                    except json.JSONDecodeError as e:
+                        log_warning(f"Failed to parse JSON from structured output in stream: {e}")
+                    except ValidationError as e:
+                        log_warning(f"Failed to validate structured output against schema in stream: {e}")
+                    except Exception as e:
+                        log_warning(f"Unexpected error parsing structured output in stream: {e}")
+
             # 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