restore docs and bump anthropic sdk and simplify model - add new test with cassette

Author: dsfaccini

docs/models/anthropic.md

@@ -144,32 +144,3 @@ async def main():
     print(f'Cache write tokens: {usage.cache_write_tokens}')
     print(f'Cache read tokens: {usage.cache_read_tokens}')
 ```
-
-## Structured outputs & strict tool calls
-
-Anthropic offers [Structured Outputs](https://docs.claude.com/en/docs/build-with-claude/structured-outputs), which force the model to emit JSON matching a supplied schema and to validate tool inputs before they reach your code. Pydantic AI enables this automatically:
-
-- When you use [`NativeOutput`][pydantic_ai.output.NativeOutput] (or set `output_mode='native'`), the agent sends Anthropic the JSON schema as an `output_format` payload and adds the required `structured-outputs-2025-11-13` beta header. The model's response will be validated just like on other providers, and `result.output` will contain your typed object.
-- Tool definitions that are strict-compatible are sent with `strict: true`, which enables Anthropic's parameter validation. You can opt out for a specific tool by passing `strict=False` to `Tool(...)` or an agent decorator.
-
-```python {test="skip"}
-from pydantic import BaseModel
-
-from pydantic_ai import Agent, NativeOutput
-from pydantic_ai.models.anthropic import AnthropicModel
-
-
-class Contact(BaseModel):
-    name: str
-    email: str
-
-
-model = AnthropicModel('claude-sonnet-4-5')
-agent = Agent(model, output_type=NativeOutput(Contact))
-result = agent.run_sync('Extract the contact info for Ada Lovelace.')
-print(result.output)
-#> Contact(name='Ada Lovelace', email='[email protected]')
-```
-
-!!! note
-    Pydantic AI automatically sets the beta headers, so you do not need to modify `model_settings.extra_headers`. If you also need to send custom `extra_body` fields, avoid supplying your own `output_format` as it will be generated for you.

docs/output.md

@@ -308,7 +308,7 @@ _(This example is complete, it can be run "as is")_
 
 #### Native Output
 
-Native Output mode uses a model's native "Structured Outputs" feature (aka "JSON Schema response format"), where the model is forced to only output text matching the provided JSON schema. Note that this is not supported by all models, and sometimes comes with restrictions. For example, Anthropic requires enabling their Structured Outputs beta (Pydantic AI handles the required headers automatically), while Gemini cannot use tools at the same time as structured output, and attempting to do so will result in an error.
+Native Output mode uses a model's native "Structured Outputs" feature (aka "JSON Schema response format"), where the model is forced to only output text matching the provided JSON schema. Note that this is not supported by all models, and sometimes comes with restrictions. For example, Gemini cannot use tools at the same time as structured output, and attempting to do so will result in an error.
 
 To use this mode, you can wrap the output type(s) in the [`NativeOutput`][pydantic_ai.output.NativeOutput] marker class that also lets you specify a `name` and `description` if the name and docstring of the type or function are not sufficient.
 

pydantic_ai_slim/pydantic_ai/models/__init__.py

@@ -57,9 +57,6 @@
     Literal[
         'anthropic:claude-3-5-haiku-20241022',
         'anthropic:claude-3-5-haiku-latest',
-        'anthropic:claude-3-5-sonnet-20240620',
-        'anthropic:claude-3-5-sonnet-20241022',
-        'anthropic:claude-3-5-sonnet-latest',
         'anthropic:claude-3-7-sonnet-20250219',
         'anthropic:claude-3-7-sonnet-latest',
         'anthropic:claude-3-haiku-20240307',

pydantic_ai_slim/pydantic_ai/models/anthropic.py

@@ -53,9 +53,6 @@
     'refusal': 'content_filter',
 }
 
-# TODO: remove once anthropic moves it out of beta
-_STRUCTURED_OUTPUTS_BETA = 'structured-outputs-2025-11-13'
-
 
 try:
     from anthropic import NOT_GIVEN, APIStatusError, AsyncStream, omit as OMIT
@@ -73,6 +70,7 @@
         BetaContentBlockParam,
         BetaImageBlockParam,
         BetaInputJSONDelta,
+        BetaJSONOutputFormatParam,
         BetaMCPToolResultBlock,
         BetaMCPToolUseBlock,
         BetaMCPToolUseBlockParam,
@@ -313,7 +311,6 @@ async def _messages_create(
         tools, strict_tools_requested = self._get_tools(model_request_parameters, model_settings)
         tools, mcp_servers, beta_features = self._add_builtin_tools(tools, model_request_parameters)
         output_format = self._build_output_format(model_request_parameters)
-        structured_output_beta_required = strict_tools_requested or bool(output_format)
 
         tool_choice: BetaToolChoiceParam | None
 
@@ -330,21 +327,14 @@ async def _messages_create(
 
         system_prompt, anthropic_messages = await self._map_message(messages, model_request_parameters, model_settings)
 
+        # Build betas list for SDK
+        betas: list[str] = list(beta_features)
+        if strict_tools_requested or output_format:
+            betas.append('structured-outputs-2025-11-13')
+
         try:
             extra_headers = model_settings.get('extra_headers', {})
             extra_headers.setdefault('User-Agent', get_user_agent())
-            if beta_features or structured_output_beta_required:
-                new_features = list(beta_features)
-                if structured_output_beta_required:
-                    new_features.append(_STRUCTURED_OUTPUTS_BETA)
-                extra_headers['anthropic-beta'] = self._format_beta_header(
-                    extra_headers.get('anthropic-beta'),
-                    new_features,
-                )
-
-            extra_body = cast(dict[str, Any] | None, model_settings.get('extra_body'))
-            if output_format is not None:
-                extra_body = self._merge_output_format_extra_body(extra_body, output_format)
 
             return await self.client.beta.messages.create(
                 max_tokens=model_settings.get('max_tokens', 4096),
@@ -354,6 +344,8 @@ async def _messages_create(
                 tools=tools or OMIT,
                 tool_choice=tool_choice or OMIT,
                 mcp_servers=mcp_servers or OMIT,
+                output_format=output_format or OMIT,
+                betas=betas or OMIT,
                 stream=stream,
                 thinking=model_settings.get('anthropic_thinking', OMIT),
                 stop_sequences=model_settings.get('stop_sequences', OMIT),
@@ -362,7 +354,7 @@ async def _messages_create(
                 timeout=model_settings.get('timeout', NOT_GIVEN),
                 metadata=model_settings.get('anthropic_metadata', OMIT),
                 extra_headers=extra_headers,
-                extra_body=extra_body,
+                extra_body=model_settings.get('extra_body'),
             )
         except APIStatusError as e:
             if (status_code := e.status_code) >= 400:
@@ -780,45 +772,18 @@ def _map_tool_definition(f: ToolDefinition) -> BetaToolParam:
             'description': f.description or '',
             'input_schema': f.parameters_json_schema,
         }
-        if f.strict is not None:
-            tool_param['strict'] = f.strict  # type: ignore[assignment]
+        if f.strict:
+            tool_param['strict'] = f.strict
         return tool_param
 
     @staticmethod
-    def _build_output_format(model_request_parameters: ModelRequestParameters) -> dict[str, Any] | None:
+    def _build_output_format(model_request_parameters: ModelRequestParameters) -> BetaJSONOutputFormatParam | None:
         if model_request_parameters.output_mode != 'native':
             return None
         output_object = model_request_parameters.output_object
-        if output_object is None:
-            return None
+        assert output_object is not None
         return {'type': 'json_schema', 'schema': output_object.json_schema}
 
-    @staticmethod
-    def _merge_output_format_extra_body(
-        existing: dict[str, Any] | None, output_format: dict[str, Any]
-    ) -> dict[str, Any]:
-        merged = dict(existing or {})
-        if 'output_format' in merged:
-            raise UserError(
-                '`model_settings.extra_body` cannot define `output_format` when using native structured output.'
-            )
-        merged['output_format'] = output_format
-        return merged
-
-    @staticmethod
-    def _format_beta_header(existing: str | None, new_features: list[str]) -> str:
-        values: list[str] = []
-        if existing:
-            values.extend(value.strip() for value in existing.split(',') if value.strip())
-        values.extend(new_features)
-        ordered: list[str] = []
-        seen: set[str] = set()
-        for value in values:
-            if value not in seen:
-                ordered.append(value)
-                seen.add(value)
-        return ','.join(ordered)
-
 
 def _map_usage(
     message: BetaMessage | BetaRawMessageStartEvent | BetaRawMessageDeltaEvent,

pydantic_ai_slim/pydantic_ai/profiles/anthropic.py

@@ -1,42 +1,28 @@
 from __future__ import annotations as _annotations
 
-import importlib
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Any, cast
+from typing import Any
 
 from .._json_schema import JsonSchema, JsonSchemaTransformer
 from . import ModelProfile
 
 TransformSchemaFunc = Callable[[Any], JsonSchema]
 
-try:  # pragma: no cover
-    _anthropic_module = importlib.import_module('anthropic')
-except Exception:
-    _anthropic_transform_schema: TransformSchemaFunc | None = None
-else:
-    _anthropic_transform_schema = cast(TransformSchemaFunc | None, getattr(_anthropic_module, 'transform_schema', None))
-
 
 @dataclass(init=False)
 class AnthropicJsonSchemaTransformer(JsonSchemaTransformer):
     """Transforms schemas to the subset supported by Anthropic structured outputs."""
 
     def walk(self) -> JsonSchema:
+        from anthropic import transform_schema
+
         schema = super().walk()
-        helper = _anthropic_transform_schema
-        if helper is None:
-            return schema
-        try:  # pragma: no branch
-            # helper may raise if schema already transformed
-            transformed = helper(schema)
-        except Exception:
-            return schema
-        if isinstance(transformed, dict):
-            return transformed
-        return schema
+        transformed = transform_schema(schema)
+        return transformed
 
     def transform(self, schema: JsonSchema) -> JsonSchema:
+        # for consistency with other transformers (openai,google)
         schema.pop('title', None)
         schema.pop('$schema', None)
         return schema

pydantic_ai_slim/pyproject.toml

@@ -71,7 +71,7 @@ openai = ["openai>=1.107.2"]
 cohere = ["cohere>=5.18.0; platform_system != 'Emscripten'"]
 vertexai = ["google-auth>=2.36.0", "requests>=2.32.2"]
 google = ["google-genai>=1.50.1"]
-anthropic = ["anthropic>=0.70.0"]
+anthropic = ["anthropic>=0.74.0"]
 groq = ["groq>=0.25.0"]
 mistral = ["mistralai>=1.9.10"]
 bedrock = ["boto3>=1.40.14"]