fix coverage and fix cassette

Author: dsfaccini

pydantic_ai_slim/pydantic_ai/models/anthropic.py

@@ -614,7 +614,7 @@ def _prepare_betas_and_headers(
             beta_value = extra_headers['anthropic-beta']
             for beta in beta_value.split(','):
                 beta_stripped = beta.strip()
-                if beta_stripped:
+                if beta_stripped:  # pragma: no branch
                     betas.add(beta_stripped)
             del extra_headers['anthropic-beta']
 

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

@@ -90,18 +90,171 @@ interactions:
       connection:
       - keep-alive
       content-length:
-      - '130'
+      - '477'
       content-type:
       - application/json
+      retry-after:
+      - '18'
       strict-transport-security:
       - max-age=31536000; includeSubDomains; preload
+      transfer-encoding:
+      - chunked
     parsed_body:
-      error:
-        message: invalid x-api-key
-        type: authentication_error
-      request_id: req_011CVKJbTXMN68Pzm15QEJpK
-      type: error
+      content:
+      - id: toolu_019JQjJerVPXLfa3AcmLrjuH
+        input: {}
+        name: get_user_country
+        type: tool_use
+      id: msg_01DhgrVv5EJDsccFZ587B9bN
+      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: 1047
+        output_tokens: 38
+        service_tier: standard
+    status:
+      code: 200
+      message: OK
+- request:
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '1424'
+      content-type:
+      - application/json
+      host:
+      - api.anthropic.com
+    method: POST
+    parsed_body:
+      max_tokens: 4096
+      messages:
+      - content:
+        - text: What language is spoken in the user country?
+          type: text
+        role: user
+      - content:
+        - id: toolu_019JQjJerVPXLfa3AcmLrjuH
+          input: {}
+          name: get_user_country
+          type: tool_use
+        role: assistant
+      - content:
+        - content: France
+          is_error: false
+          tool_use_id: toolu_019JQjJerVPXLfa3AcmLrjuH
+          type: tool_result
+        role: user
+      model: claude-sonnet-4-5
+      output_format:
+        schema:
+          additionalProperties: false
+          properties:
+            result:
+              anyOf:
+              - additionalProperties: false
+                description: A city and its country.
+                properties:
+                  data:
+                    additionalProperties: false
+                    properties:
+                      city:
+                        type: string
+                      country:
+                        type: string
+                    required:
+                    - city
+                    - country
+                    type: object
+                  kind:
+                    description: '{const: CityLocation}'
+                    type: string
+                required:
+                - kind
+                - data
+                type: object
+              - additionalProperties: false
+                properties:
+                  data:
+                    additionalProperties: false
+                    properties:
+                      country:
+                        type: string
+                      language:
+                        type: string
+                    required:
+                    - country
+                    - language
+                    type: object
+                  kind:
+                    description: '{const: CountryLanguage}'
+                    type: string
+                required:
+                - kind
+                - data
+                type: object
+          required:
+          - result
+          type: object
+        type: json_schema
+      stream: false
+      tool_choice:
+        type: auto
+      tools:
+      - description: ''
+        input_schema:
+          additionalProperties: false
+          properties: {}
+          type: object
+        name: get_user_country
+        strict: true
+    uri: https://api.anthropic.com/v1/messages?beta=true
+  response:
+    headers:
+      connection:
+      - keep-alive
+      content-length:
+      - '509'
+      content-type:
+      - application/json
+      retry-after:
+      - '15'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      transfer-encoding:
+      - chunked
+    parsed_body:
+      content:
+      - text: '{"result":{"kind":"CountryLanguage","data":{"country":"France","language":"French"}}}'
+        type: text
+      id: msg_01LeExcS3t3YwwYs1tram43F
+      model: claude-sonnet-4-5-20250929
+      role: assistant
+      stop_reason: end_turn
+      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: 1099
+        output_tokens: 26
+        service_tier: standard
     status:
-      code: 401
-      message: Unauthorized
+      code: 200
+      message: OK
 version: 1

tests/models/anthropic/test_output.py

@@ -359,12 +359,31 @@ async def get_user_country() -> str:
     result = await agent.run('What is the capital of the user country?')
     # Should return CityLocation since we asked about capital
     assert isinstance(result.output, city_location_schema | country_language_schema)
-    if isinstance(result.output, city_location_schema):
+    if isinstance(result.output, city_location_schema):  # pragma: no branch
         assert result.output.city == 'Paris'  # type: ignore[attr-defined]
         assert result.output.country == 'France'  # type: ignore[attr-defined]
-    else:  # pragma: no cover
-        # This branch is not hit in this test, but we keep the structure for completeness
-        pass
+
+
+async def test_anthropic_native_output_multiple_language(
+    allow_model_requests: None,
+    anthropic_sonnet_4_5: AnthropicModel,
+    city_location_schema: type[BaseModel],
+    country_language_schema: type[BaseModel],
+    make_agent: MakeAgentType,
+):
+    """Test native output with union returns the second schema type."""
+    agent = make_agent(anthropic_sonnet_4_5, output_type=NativeOutput([city_location_schema, country_language_schema]))
+
+    @agent.tool_plain
+    async def get_user_country() -> str:
+        return 'France'
+
+    result = await agent.run('What language is spoken in the user country?')
+    # Should return CountryLanguage since we asked about language
+    assert isinstance(result.output, city_location_schema | country_language_schema)
+    if isinstance(result.output, country_language_schema):
+        assert result.output.country == 'France'  # type: ignore[attr-defined]
+        assert result.output.language == 'French'  # type: ignore[attr-defined]
 
 
 async def test_anthropic_auto_mode_sonnet_4_5(
@@ -375,6 +394,7 @@ async def test_anthropic_auto_mode_sonnet_4_5(
 ):
     """Test auto mode with sonnet-4.5 (should use native output automatically)."""
     agent = make_agent(anthropic_sonnet_4_5, output_type=city_location_schema)
+    assert agent.model.profile.supports_json_schema_output  # pyright: ignore[reportUnknownMemberType,reportAttributeAccessIssue,reportOptionalMemberAccess]
 
     result = await agent.run('What is the capital of France?')
     assert result.output == snapshot(city_location_schema(city='Paris', country='France'))
@@ -388,6 +408,7 @@ async def test_anthropic_auto_mode_sonnet_4_0(
 ):
     """Test auto mode with sonnet-4.0 (should fall back to prompted output)."""
     agent = make_agent(anthropic_sonnet_4_0, output_type=city_location_schema)
+    assert agent.model.profile.supports_json_schema_output is False  # pyright: ignore[reportUnknownMemberType,reportAttributeAccessIssue,reportOptionalMemberAccess]
 
     result = await agent.run('What is the capital of France?')
     assert result.output == snapshot(city_location_schema(city='Paris', country='France'))

tests/models/test_anthropic.py

@@ -6518,6 +6518,23 @@ async def test_anthropic_model_usage_limit_not_exceeded(
     )
 
 
+async def test_anthropic_count_tokens_with_mock(allow_model_requests: None):
+    """Test that count_tokens is called on the mock client."""
+    c = completion_message(
+        [BetaTextBlock(text='hello world', type='text')], BetaUsage(input_tokens=5, output_tokens=10)
+    )
+    mock_client = MockAnthropic.create_mock(c)
+    m = AnthropicModel('claude-haiku-4-5', provider=AnthropicProvider(anthropic_client=mock_client))
+    agent = Agent(m)
+
+    result = await agent.run('hello', usage_limits=UsageLimits(input_tokens_limit=20, count_tokens_before_request=True))
+    assert result.output == 'hello world'
+    assert len(mock_client.chat_completion_kwargs) == 2  # type: ignore
+    count_tokens_kwargs = mock_client.chat_completion_kwargs[0]  # type: ignore
+    assert 'model' in count_tokens_kwargs
+    assert 'messages' in count_tokens_kwargs
+
+
 @pytest.mark.vcr()
 async def test_anthropic_count_tokens_error(allow_model_requests: None, anthropic_api_key: str):
     """Test that errors convert to ModelHTTPError."""