add model-based support and add tests

Author: dsfaccini

pydantic_ai_slim/pydantic_ai/models/__init__.py

@@ -377,7 +377,10 @@ async def request(
         model_settings: ModelSettings | None,
         model_request_parameters: ModelRequestParameters,
     ) -> ModelResponse:
-        """Make a request to the model."""
+        """Make a request to the model.
+
+        This is ultimately called by `pydantic_ai._agent_graph.ModelRequestNode._make_request(...)`.
+        """
         raise NotImplementedError()
 
     async def count_tokens(

pydantic_ai_slim/pydantic_ai/models/anthropic.py

@@ -199,8 +199,9 @@ def __init__(
             model_name: The name of the Anthropic model to use. List of model names available
                 [here](https://docs.anthropic.com/en/docs/about-claude/models).
             provider: The provider to use for the Anthropic API. Can be either the string 'anthropic' or an
-                instance of `Provider[AsyncAnthropicClient]`. If not provided, the other parameters will be used.
+                instance of `Provider[AsyncAnthropicClient]`. Defaults to 'anthropic'.
             profile: The model profile to use. Defaults to a profile picked by the provider based on the model name.
+                The default 'anthropic' provider will use the default `..profiles.anthropic_model_profile`.
             settings: Default model settings for this model instance.
         """
         self._model_name = model_name
@@ -290,13 +291,14 @@ def prepare_request(
             and thinking.get('type') == 'enabled'
         ):
             if model_request_parameters.output_mode == 'auto':
-                model_request_parameters = replace(model_request_parameters, output_mode='prompted')
+                output_mode = 'native' if self.profile.supports_json_schema_output else 'prompted'
+                model_request_parameters = replace(model_request_parameters, output_mode=output_mode)
             elif (
                 model_request_parameters.output_mode == 'tool' and not model_request_parameters.allow_text_output
             ):  # pragma: no branch
                 # This would result in `tool_choice=required`, which Anthropic does not support with thinking.
                 raise UserError(
-                    'Anthropic does not support thinking and output tools at the same time. Use `output_type=PromptedOutput(...)` instead.'
+                    'Anthropic does not support thinking and output tools at the same time. Use `output_type=NativeOutput(...)` instead.'
                 )
         return super().prepare_request(model_settings, model_request_parameters)
 
@@ -330,15 +332,15 @@ async def _messages_create(
         # standalone function to make it easier to override
         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)
+        native_format = self._native_output_format(model_request_parameters)
 
         tool_choice = self._infer_tool_choice(tools, model_settings, model_request_parameters)
 
         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:
+        if strict_tools_requested or native_format:
             betas.append('structured-outputs-2025-11-13')
 
         try:
@@ -354,7 +356,7 @@ 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,
+                output_format=native_format or OMIT,
                 betas=betas or OMIT,
                 stream=stream,
                 thinking=model_settings.get('anthropic_thinking', OMIT),
@@ -849,19 +851,18 @@ async def _map_user_prompt(
                 else:
                     raise RuntimeError(f'Unsupported content type: {type(item)}')  # pragma: no cover
 
-    @staticmethod
-    def _map_tool_definition(f: ToolDefinition) -> BetaToolParam:
+    def _map_tool_definition(self, f: ToolDefinition) -> BetaToolParam:
         tool_param: BetaToolParam = {
             'name': f.name,
             'description': f.description or '',
             'input_schema': f.parameters_json_schema,
         }
-        if f.strict:
+        if f.strict and self.profile.supports_json_schema_output:  # pragma: no branch
             tool_param['strict'] = f.strict
         return tool_param
 
     @staticmethod
-    def _build_output_format(model_request_parameters: ModelRequestParameters) -> BetaJSONOutputFormatParam | None:
+    def _native_output_format(model_request_parameters: ModelRequestParameters) -> BetaJSONOutputFormatParam | None:
         if model_request_parameters.output_mode != 'native':
             return None
         output_object = model_request_parameters.output_object

pydantic_ai_slim/pydantic_ai/profiles/__init__.py

@@ -25,9 +25,19 @@ class ModelProfile:
     supports_tools: bool = True
     """Whether the model supports tools."""
     supports_json_schema_output: bool = False
-    """Whether the model supports JSON schema output."""
+    """Whether the model supports JSON schema output.
+
+    This is also referred to as 'native' support for structured output.
+    This is the preferred way to get structured output from the model when available.
+    Relates to the `NativeOutput` output type.
+    """
     supports_json_object_output: bool = False
-    """Whether the model supports JSON object output."""
+    """Whether the model supports JSON object output.
+
+    This is different from `supports_json_schema_output` in that it indicates whether the model can return arbitrary JSON objects,
+    rather than only JSON objects that conform to a provided JSON schema.
+    Relates to the `PromptedOutput` output type.
+    """
     supports_image_output: bool = False
     """Whether the model supports image output."""
     default_structured_output_mode: StructuredOutputMode = 'tool'

pydantic_ai_slim/pydantic_ai/profiles/anthropic.py

@@ -1,19 +1,17 @@
 from __future__ import annotations as _annotations
 
-from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Any
-
-from anthropic.lib._parse._transform import SupportedStringFormats
 
 from .._json_schema import JsonSchema, JsonSchemaTransformer
 from . import ModelProfile
 
-TransformSchemaFunc = Callable[[Any], JsonSchema]
-
 
 def _schema_is_lossless(schema: JsonSchema) -> bool:  # noqa: C901
-    """Return True when `anthropic.transform_schema` won't need to drop constraints."""
+    """Return True when `anthropic.transform_schema` won't need to drop constraints.
+
+    Checks are performed based on https://docs.claude.com/en/docs/build-with-claude/structured-outputs#how-sdk-transformation-works
+    """
+    from anthropic.lib._parse._transform import SupportedStringFormats
 
     def _walk(node: JsonSchema) -> bool:  # noqa: C901
         if not isinstance(node, dict):
@@ -39,6 +37,8 @@ def _walk(node: JsonSchema) -> bool:  # noqa: C901
         node.pop('description', None)
         node.pop('title', None)
 
+        # every sub-schema in the list must itself be lossless -> `all(_walk(item) for item in any_of)`
+        # the wrapper object must not have any other unsupported fields -> `and not node`
         if isinstance(any_of, list):
             return all(_walk(item) for item in any_of) and not node  # pyright: ignore[reportUnknownVariableType, reportUnknownArgumentType]
         if isinstance(one_of, list):
@@ -104,8 +104,12 @@ def transform(self, schema: JsonSchema) -> JsonSchema:
 
 def anthropic_model_profile(model_name: str) -> ModelProfile | None:
     """Get the model profile for an Anthropic model."""
+    models_that_support_json_schema_output = ('claude-sonnet-4-5', 'claude-opus-4-1')
+    # anthropic introduced support for both structured outputs and strict tool use
+    # https://docs.claude.com/en/docs/build-with-claude/structured-outputs#example-usage
+    supports_json_schema_output = model_name.startswith(models_that_support_json_schema_output)
     return ModelProfile(
         thinking_tags=('<thinking>', '</thinking>'),
-        supports_json_schema_output=True,
+        supports_json_schema_output=supports_json_schema_output,
         json_schema_transformer=AnthropicJsonSchemaTransformer,
     )

tests/CLAUDE.md

@@ -0,0 +1,45 @@
+# Testing conventions
+
+## general rules
+
+- prefer using `snapshot()` instead of line-by-line assertions
+- unless the snapshot is too big and you only need to check specific values
+
+### about static typing
+
+- other codebases don't use types in their test files
+- but this codebase is fully typed with static types
+- proper types are required and the pre-commit hook sstrictly checks for types and won't allow commits with type errors
+- so you're required to use proper types in test files as well
+- refer to `tests/models/anthropic/conftest.py` for examples of typing in test files
+
+## for testing filepaths
+
+- define your function with a parameter `tmp_path: Path`
+
+## examples
+
+### inline vs snapshot
+```python
+    completion_kwargs = get_mock_chat_completion_kwargs(mock_client)[0]
+    assert 'tools' in completion_kwargs
+    tools = completion_kwargs['tools']
+    # By default, tools should be strict-compatible
+    assert any(tool.get('strict') is True for tool in tools)
+    # Should include structured-outputs beta
+    assert 'structured-outputs-2025-11-13' in completion_kwargs.get('betas', [])
+```
+
+can be simplified to
+
+```python
+    completion_kwargs = get_mock_chat_completion_kwargs(mock_client)[0]
+    tools = completion_kwargs['tools']
+    betas = completion_kwargs['betas']
+    assert tools = snapshot()
+    assert betas = snapshot()
+```
+
+- it's preferable to use the snapshot, run the test and check what comes out
+- if the snapshot is too large in comparison with the equivalent inline assertions, it's ok to keep the inline assertions
+- confirm with the user what they prefer in cases that don't have a clear preference

tests/models/anthropic/__init__.py

@@ -0,0 +1 @@
+"""Tests for Anthropic models."""

tests/models/anthropic/cassettes/test_output/test_anthropic_auto_mode_sonnet_4_0.yaml

@@ -0,0 +1,83 @@
+interactions:
+- request:
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '422'
+      content-type:
+      - application/json
+      host:
+      - api.anthropic.com
+    method: POST
+    parsed_body:
+      max_tokens: 4096
+      messages:
+      - content:
+        - text: What is the capital of France?
+          type: text
+        role: user
+      model: claude-sonnet-4-0
+      stream: false
+      tool_choice:
+        type: any
+      tools:
+      - description: A city and its country.
+        input_schema:
+          additionalProperties: false
+          properties:
+            city:
+              type: string
+            country:
+              type: string
+          required:
+          - city
+          - country
+          type: object
+        name: final_result
+    uri: https://api.anthropic.com/v1/messages?beta=true
+  response:
+    headers:
+      connection:
+      - keep-alive
+      content-length:
+      - '503'
+      content-type:
+      - application/json
+      retry-after:
+      - '59'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      transfer-encoding:
+      - chunked
+    parsed_body:
+      content:
+      - id: toolu_011CgnivckJbK9QLLe9LN1Rt
+        input:
+          city: Paris
+          country: France
+        name: final_result
+        type: tool_use
+      id: msg_01QgYbVnhrJe61wKzuPNxcsQ
+      model: claude-sonnet-4-20250514
+      role: assistant
+      stop_reason: tool_use
+      stop_sequence: null
+      type: message
+      usage:
+        cache_creation:
+          ephemeral_1h_input_tokens: 0
+          ephemeral_5m_input_tokens: 0
+        cache_creation_input_tokens: 0
+        cache_read_input_tokens: 0
+        input_tokens: 402
+        output_tokens: 55
+        service_tier: standard
+    status:
+      code: 200
+      message: OK
+version: 1

tests/models/anthropic/cassettes/test_output/test_anthropic_auto_mode_sonnet_4_5.yaml

@@ -0,0 +1,84 @@
+interactions:
+- request:
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '436'
+      content-type:
+      - application/json
+      host:
+      - api.anthropic.com
+    method: POST
+    parsed_body:
+      max_tokens: 4096
+      messages:
+      - content:
+        - text: What is the capital of France?
+          type: text
+        role: user
+      model: claude-sonnet-4-5
+      stream: false
+      tool_choice:
+        type: any
+      tools:
+      - description: A city and its country.
+        input_schema:
+          additionalProperties: false
+          properties:
+            city:
+              type: string
+            country:
+              type: string
+          required:
+          - city
+          - country
+          type: object
+        name: final_result
+        strict: true
+    uri: https://api.anthropic.com/v1/messages?beta=true
+  response:
+    headers:
+      connection:
+      - keep-alive
+      content-length:
+      - '505'
+      content-type:
+      - application/json
+      retry-after:
+      - '1'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      transfer-encoding:
+      - chunked
+    parsed_body:
+      content:
+      - id: toolu_01M1wKLEV2vS9t2oy4RihDKo
+        input:
+          city: Paris
+          country: France
+        name: final_result
+        type: tool_use
+      id: msg_01AW9scKTcw7CLGFCFrzfGNw
+      model: claude-sonnet-4-5-20250929
+      role: assistant
+      stop_reason: tool_use
+      stop_sequence: null
+      type: message
+      usage:
+        cache_creation:
+          ephemeral_1h_input_tokens: 0
+          ephemeral_5m_input_tokens: 0
+        cache_creation_input_tokens: 0
+        cache_read_input_tokens: 0
+        input_tokens: 675
+        output_tokens: 55
+        service_tier: standard
+    status:
+      code: 200
+      message: OK
+version: 1