pydantic-ai 0.2.12__tar.gz → 0.2.14__tar.gz

{pydantic_ai-0.2.12 → pydantic_ai-0.2.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai
-Version: 0.2.12
+Version: 0.2.14
 Summary: Agent Framework / shim to use Pydantic with LLMs
 Project-URL: Homepage, https://ai.pydantic.dev
 Project-URL: Source, https://github.com/pydantic/pydantic-ai
@@ -28,9 +28,9 @@ Classifier: Topic :: Internet
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
-Requires-Dist: pydantic-ai-slim[a2a,anthropic,bedrock,cli,cohere,evals,google,groq,mcp,mistral,openai,vertexai]==0.2.12
+Requires-Dist: pydantic-ai-slim[a2a,anthropic,bedrock,cli,cohere,evals,google,groq,mcp,mistral,openai,vertexai]==0.2.14
 Provides-Extra: examples
-Requires-Dist: pydantic-ai-examples==0.2.12; extra == 'examples'
+Requires-Dist: pydantic-ai-examples==0.2.14; extra == 'examples'
 Provides-Extra: logfire
 Requires-Dist: logfire>=3.11.0; extra == 'logfire'
 Description-Content-Type: text/markdown

{pydantic_ai-0.2.12 → pydantic_ai-0.2.14}/tests/evals/test_evaluator_common.py

@@ -208,11 +208,21 @@ async def test_llm_judge_evaluator(mocker: MockerFixture):
     mock_judge_input_output = mocker.patch('pydantic_evals.evaluators.llm_as_a_judge.judge_input_output')
     mock_judge_input_output.return_value = mock_grading_output
 
+    # Mock the judge_input_output_expected function
+    mock_judge_input_output_expected = mocker.patch(
+        'pydantic_evals.evaluators.llm_as_a_judge.judge_input_output_expected'
+    )
+    mock_judge_input_output_expected.return_value = mock_grading_output
+
+    # Mock the judge_output_expected function
+    mock_judge_output_expected = mocker.patch('pydantic_evals.evaluators.llm_as_a_judge.judge_output_expected')
+    mock_judge_output_expected.return_value = mock_grading_output
+
     ctx = EvaluatorContext(
         name='test',
         inputs={'prompt': 'Hello'},
         metadata=None,
-        expected_output=None,
+        expected_output='Hello',
         output='Hello world',
         duration=0.0,
         _span_tree=SpanTreeRecordingError('spans were not recorded'),
@@ -238,6 +248,29 @@ async def test_llm_judge_evaluator(mocker: MockerFixture):
         {'prompt': 'Hello'}, 'Hello world', 'Output contains input', 'openai:gpt-4o', None
     )
 
+    # Test with input and expected output
+    evaluator = LLMJudge(
+        rubric='Output contains input', include_input=True, include_expected_output=True, model='openai:gpt-4o'
+    )
+    assert to_jsonable_python(await evaluator.evaluate(ctx)) == snapshot(
+        {'LLMJudge': {'value': True, 'reason': 'Test passed'}}
+    )
+
+    mock_judge_input_output_expected.assert_called_once_with(
+        {'prompt': 'Hello'}, 'Hello world', 'Hello', 'Output contains input', 'openai:gpt-4o', None
+    )
+
+    # Test with output and expected output
+    evaluator = LLMJudge(
+        rubric='Output contains input', include_input=False, include_expected_output=True, model='openai:gpt-4o'
+    )
+    assert to_jsonable_python(await evaluator.evaluate(ctx)) == snapshot(
+        {'LLMJudge': {'value': True, 'reason': 'Test passed'}}
+    )
+
+    mock_judge_output_expected.assert_called_once_with(
+        'Hello world', 'Hello', 'Output contains input', 'openai:gpt-4o', None
+    )
     # Test with failing result
     mock_grading_output.score = 0.0
     mock_grading_output.pass_ = False
@@ -273,13 +306,21 @@ async def test_llm_judge_evaluator_with_model_settings(mocker: MockerFixture):
     mock_judge_input_output = mocker.patch('pydantic_evals.evaluators.llm_as_a_judge.judge_input_output')
     mock_judge_input_output.return_value = mock_grading_output
 
+    mock_judge_input_output_expected = mocker.patch(
+        'pydantic_evals.evaluators.llm_as_a_judge.judge_input_output_expected'
+    )
+    mock_judge_input_output_expected.return_value = mock_grading_output
+
+    mock_judge_output_expected = mocker.patch('pydantic_evals.evaluators.llm_as_a_judge.judge_output_expected')
+    mock_judge_output_expected.return_value = mock_grading_output
+
     custom_model_settings = ModelSettings(temperature=0.77)
 
     ctx = EvaluatorContext(
         name='test_custom_settings',
         inputs={'prompt': 'Hello Custom'},
         metadata=None,
-        expected_output=None,
+        expected_output='Hello',
         output='Hello world custom settings',
         duration=0.0,
         _span_tree=SpanTreeRecordingError('spans were not recorded'),
@@ -314,6 +355,45 @@ async def test_llm_judge_evaluator_with_model_settings(mocker: MockerFixture):
         custom_model_settings,
     )
 
+    # Test with input and expected output, with custom model_settings
+    evaluator_with_input_expected = LLMJudge(
+        rubric='Output contains input with custom settings',
+        include_input=True,
+        include_expected_output=True,
+        model='openai:gpt-3.5-turbo',
+        model_settings=custom_model_settings,
+    )
+    assert to_jsonable_python(await evaluator_with_input_expected.evaluate(ctx)) == snapshot(
+        {'LLMJudge': {'value': True, 'reason': 'Test passed with settings'}}
+    )
+    mock_judge_input_output_expected.assert_called_once_with(
+        {'prompt': 'Hello Custom'},
+        'Hello world custom settings',
+        'Hello',
+        'Output contains input with custom settings',
+        'openai:gpt-3.5-turbo',
+        custom_model_settings,
+    )
+
+    # Test with output and expected output
+    evaluator_with_output_expected = LLMJudge(
+        rubric='Output contains input with custom settings',
+        include_input=False,
+        include_expected_output=True,
+        model='openai:gpt-3.5-turbo',
+        model_settings=custom_model_settings,
+    )
+    assert to_jsonable_python(await evaluator_with_output_expected.evaluate(ctx)) == snapshot(
+        {'LLMJudge': {'value': True, 'reason': 'Test passed with settings'}}
+    )
+    mock_judge_output_expected.assert_called_once_with(
+        'Hello world custom settings',
+        'Hello',
+        'Output contains input with custom settings',
+        'openai:gpt-3.5-turbo',
+        custom_model_settings,
+    )
+
 
 async def test_python():
     """Test Python evaluator."""

{pydantic_ai-0.2.12 → pydantic_ai-0.2.14}/tests/evals/test_llm_as_a_judge.py

@@ -11,7 +11,9 @@ with try_import() as imports_successful:
         GradingOutput,
         _stringify,  # pyright: ignore[reportPrivateUsage]
         judge_input_output,
+        judge_input_output_expected,
         judge_output,
+        judge_output_expected,
     )
 
 pytestmark = [pytest.mark.skipif(not imports_successful(), reason='pydantic-evals not installed'), pytest.mark.anyio]
@@ -167,3 +169,114 @@ async def test_judge_input_output_with_model_settings_mock(mocker: MockerFixture
     assert call_kwargs['model_settings'] == test_model_settings
     # Check if 'model' kwarg is passed, its value will be the default model or None
     assert 'model' in call_kwargs
+
+
+@pytest.mark.anyio
+async def test_judge_input_output_expected_mock(mocker: MockerFixture):
+    """Test judge_input_output_expected function with mocked agent."""
+    # Mock the agent run method
+    mock_result = mocker.MagicMock()
+    mock_result.output = GradingOutput(reason='Test passed', pass_=True, score=1.0)
+    mock_run = mocker.patch('pydantic_ai.Agent.run', return_value=mock_result)
+
+    # Test with string input and output
+    result = await judge_input_output_expected('Hello', 'Hello world', 'Hello', 'Output contains input')
+    assert isinstance(result, GradingOutput)
+    assert result.reason == 'Test passed'
+    assert result.pass_ is True
+    assert result.score == 1.0
+
+    # Verify the agent was called with correct prompt
+    mock_run.assert_called_once()
+    call_args = mock_run.call_args[0]
+    assert '<Input>\nHello\n</Input>' in call_args[0]
+    assert '<ExpectedOutput>\nHello\n</ExpectedOutput>' in call_args[0]
+    assert '<Output>\nHello world\n</Output>' in call_args[0]
+    assert '<Rubric>\nOutput contains input\n</Rubric>' in call_args[0]
+
+
+@pytest.mark.anyio
+async def test_judge_input_output_expected_with_model_settings_mock(mocker: MockerFixture):
+    """Test judge_input_output_expected function with model_settings and mocked agent."""
+    mock_result = mocker.MagicMock()
+    mock_result.output = GradingOutput(reason='Test passed with settings', pass_=True, score=1.0)
+    mock_run = mocker.patch('pydantic_ai.Agent.run', return_value=mock_result)
+
+    test_model_settings = ModelSettings(temperature=1)
+
+    result = await judge_input_output_expected(
+        'Hello settings',
+        'Hello world with settings',
+        'Hello',
+        'Output contains input with settings',
+        model_settings=test_model_settings,
+    )
+    assert isinstance(result, GradingOutput)
+    assert result.reason == 'Test passed with settings'
+    assert result.pass_ is True
+    assert result.score == 1.0
+
+    mock_run.assert_called_once()
+    call_args, call_kwargs = mock_run.call_args
+    assert '<Input>\nHello settings\n</Input>' in call_args[0]
+    assert '<ExpectedOutput>\nHello\n</ExpectedOutput>' in call_args[0]
+    assert '<Output>\nHello world with settings\n</Output>' in call_args[0]
+    assert '<Rubric>\nOutput contains input with settings\n</Rubric>' in call_args[0]
+    assert call_kwargs['model_settings'] == test_model_settings
+    # Check if 'model' kwarg is passed, its value will be the default model or None
+    assert 'model' in call_kwargs
+
+
+@pytest.mark.anyio
+async def test_judge_output_expected_mock(mocker: MockerFixture):
+    """Test judge_output_expected function with mocked agent."""
+    # Mock the agent run method
+    mock_result = mocker.MagicMock()
+    mock_result.output = GradingOutput(reason='Test passed', pass_=True, score=1.0)
+    mock_run = mocker.patch('pydantic_ai.Agent.run', return_value=mock_result)
+
+    # Test with string output and expected output
+    result = await judge_output_expected('Hello world', 'Hello', 'Output contains input')
+    assert isinstance(result, GradingOutput)
+    assert result.reason == 'Test passed'
+    assert result.pass_ is True
+    assert result.score == 1.0
+
+    # Verify the agent was called with correct prompt
+    mock_run.assert_called_once()
+    call_args = mock_run.call_args[0]
+    assert '<Input>' not in call_args[0]
+    assert '<ExpectedOutput>\nHello\n</ExpectedOutput>' in call_args[0]
+    assert '<Output>\nHello world\n</Output>' in call_args[0]
+    assert '<Rubric>\nOutput contains input\n</Rubric>' in call_args[0]
+
+
+@pytest.mark.anyio
+async def test_judge_output_expected_with_model_settings_mock(mocker: MockerFixture):
+    """Test judge_output_expected function with model_settings and mocked agent."""
+    mock_result = mocker.MagicMock()
+    mock_result.output = GradingOutput(reason='Test passed with settings', pass_=True, score=1.0)
+    mock_run = mocker.patch('pydantic_ai.Agent.run', return_value=mock_result)
+
+    test_model_settings = ModelSettings(temperature=1)
+
+    result = await judge_output_expected(
+        'Hello world with settings',
+        'Hello',
+        'Output contains input with settings',
+        model_settings=test_model_settings,
+    )
+    assert isinstance(result, GradingOutput)
+    assert result.reason == 'Test passed with settings'
+    assert result.pass_ is True
+    assert result.score == 1.0
+
+    mock_run.assert_called_once()
+    call_args, call_kwargs = mock_run.call_args
+    assert '<Input>' not in call_args[0]
+    assert '<ExpectedOutput>\nHello\n</ExpectedOutput>' in call_args[0]
+    assert '<Output>\nHello world with settings\n</Output>' in call_args[0]
+    assert '<Rubric>\nOutput contains input with settings\n</Rubric>' in call_args[0]
+    assert call_kwargs['model_settings'] == test_model_settings
+    # Check if 'model' kwarg is passed, its value will be the default model or None
+    assert 'model' in call_kwargs

pydantic_ai-0.2.14/tests/models/cassettes/test_openai/test_compatible_api_with_tool_calls_without_id.yaml

@@ -0,0 +1,159 @@
+interactions:
+- request:
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '326'
+      content-type:
+      - application/json
+      host:
+      - generativelanguage.googleapis.com
+    method: POST
+    parsed_body:
+      messages:
+      - content: What is the current time?
+        role: user
+      model: gemini-2.5-pro-preview-05-06
+      stream: false
+      tool_choice: auto
+      tools:
+      - function:
+          description: Get the current time.
+          name: get_current_time
+          parameters:
+            additionalProperties: false
+            properties: {}
+            type: object
+        type: function
+    uri: https://generativelanguage.googleapis.com/v1beta/openai/chat/completions
+  response:
+    headers:
+      alt-svc:
+      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
+      content-length:
+      - '1166'
+      content-type:
+      - application/json
+      server-timing:
+      - gfet4t7; dur=1609
+      transfer-encoding:
+      - chunked
+      vary:
+      - Origin
+      - X-Origin
+      - Referer
+    parsed_body:
+      choices:
+      - finish_reason: tool_calls
+        index: 0
+        message:
+          extra_content:
+            google:
+              thought: true
+              thought_signature: AVSoXO4AzAXs7GGvOY63fp8CwJK3yR8HbUPhxhfN2HaPvJnscmZCkaWvckz5NL3nIMK+si/baQcsM2Q8ME9V1RQrb3w1IKceWfjO3kHPL11odY/p6Us4GkkvJqKU/OgUnbAMbuvNdX1pyXWZUrQ7WyXZ5F4mjbxBSCLiVOTdFlK53zn+ajq5JIuG9AYHgwE/sJxUUpvNd6RcWvZR3fQb8gufjCspiO2ZdInRcdGsz/+XftFHxFbXkdtCRAw74AtjlN5osb+KgDYojdohKIEit9DcTBe7hI7oEHWMfnqYSgGrrad4FJpNB3jXmSFevE2iYYKUBzWvxJNj8fIYrCC0g4rJ1aJvuoU=
+          role: assistant
+          thought_signature: AVSoXO4AzAXs7GGvOY63fp8CwJK3yR8HbUPhxhfN2HaPvJnscmZCkaWvckz5NL3nIMK+si/baQcsM2Q8ME9V1RQrb3w1IKceWfjO3kHPL11odY/p6Us4GkkvJqKU/OgUnbAMbuvNdX1pyXWZUrQ7WyXZ5F4mjbxBSCLiVOTdFlK53zn+ajq5JIuG9AYHgwE/sJxUUpvNd6RcWvZR3fQb8gufjCspiO2ZdInRcdGsz/+XftFHxFbXkdtCRAw74AtjlN5osb+KgDYojdohKIEit9DcTBe7hI7oEHWMfnqYSgGrrad4FJpNB3jXmSFevE2iYYKUBzWvxJNj8fIYrCC0g4rJ1aJvuoU=
+          tool_calls:
+          - function:
+              arguments: '{}'
+              name: get_current_time
+            id: ''
+            type: function
+      created: 1748902365
+      id: 3SE-aKjdCcCEz7IPxpqjCA
+      model: gemini-2.5-pro-preview-05-06
+      object: chat.completion
+      usage:
+        completion_tokens: 12
+        prompt_tokens: 35
+        total_tokens: 109
+    status:
+      code: 200
+      message: OK
+- request:
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '575'
+      content-type:
+      - application/json
+      host:
+      - generativelanguage.googleapis.com
+    method: POST
+    parsed_body:
+      messages:
+      - content: What is the current time?
+        role: user
+      - role: assistant
+        tool_calls:
+        - function:
+            arguments: '{}'
+            name: get_current_time
+          id: pyd_ai_cee885c699414386a7e14b7ec43cadbc
+          type: function
+      - content: Noon
+        role: tool
+        tool_call_id: pyd_ai_cee885c699414386a7e14b7ec43cadbc
+      model: gemini-2.5-pro-preview-05-06
+      stream: false
+      tool_choice: auto
+      tools:
+      - function:
+          description: Get the current time.
+          name: get_current_time
+          parameters:
+            additionalProperties: false
+            properties: {}
+            type: object
+        type: function
+    uri: https://generativelanguage.googleapis.com/v1beta/openai/chat/completions
+  response:
+    headers:
+      alt-svc:
+      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
+      content-length:
+      - '755'
+      content-type:
+      - application/json
+      server-timing:
+      - gfet4t7; dur=1097
+      transfer-encoding:
+      - chunked
+      vary:
+      - Origin
+      - X-Origin
+      - Referer
+    parsed_body:
+      choices:
+      - finish_reason: stop
+        index: 0
+        message:
+          content: The current time is Noon.
+          extra_content:
+            google:
+              thought: true
+              thought_signature: AVSoXO4/lu90Bn7IxVcWAjD6KH3ZHMmsCX1tnPJERDI6SZb63hrSEtmJT/v+sn2SzlecMoXBVmtcrd3keFszUgDpLjFm1gB+uMzLS1IqPdEAh+m5S71k1hfStNMFen63UnphYHWt4UrjVHXckysRLVJjCuMmE01hQXcVh9b3YXvfWfZEFA==
+          role: assistant
+          thought_signature: AVSoXO4/lu90Bn7IxVcWAjD6KH3ZHMmsCX1tnPJERDI6SZb63hrSEtmJT/v+sn2SzlecMoXBVmtcrd3keFszUgDpLjFm1gB+uMzLS1IqPdEAh+m5S71k1hfStNMFen63UnphYHWt4UrjVHXckysRLVJjCuMmE01hQXcVh9b3YXvfWfZEFA==
+      created: 1748902366
+      id: 3iE-aNK3EIGJz7IPt_mYoAs
+      model: gemini-2.5-pro-preview-05-06
+      object: chat.completion
+      usage:
+        completion_tokens: 6
+        prompt_tokens: 66
+        total_tokens: 100
+    status:
+      code: 200
+      message: OK
+version: 1

{pydantic_ai-0.2.12 → pydantic_ai-0.2.14}/tests/models/test_gemini.py

@@ -41,9 +41,13 @@ from pydantic_ai.models.gemini import (
     _GeminiCandidates,
     _GeminiContent,
     _GeminiFunction,
+    _GeminiFunctionCall,
     _GeminiFunctionCallingConfig,
+    _GeminiFunctionCallPart,
     _GeminiResponse,
     _GeminiSafetyRating,
+    _GeminiTextPart,
+    _GeminiThoughtPart,
     _GeminiToolConfig,
     _GeminiTools,
     _GeminiUsageMetaData,
@@ -898,8 +902,11 @@ async def test_stream_text_heterogeneous(get_gemini_client: GetGeminiClient):
             _GeminiContent(
                 role='model',
                 parts=[
-                    {'text': 'foo'},
-                    {'function_call': {'name': 'get_location', 'args': {'loc_name': 'San Fransisco'}}},
+                    _GeminiThoughtPart(thought=True, thought_signature='test-signature-value'),
+                    _GeminiTextPart(text='foo'),
+                    _GeminiFunctionCallPart(
+                        function_call=_GeminiFunctionCall(name='get_location', args={'loc_name': 'San Fransisco'})
+                    ),
                 ],
             )
         ),
@@ -1327,3 +1334,23 @@ async def test_gemini_no_finish_reason(get_gemini_client: GetGeminiClient):
     for message in result.all_messages():
         if isinstance(message, ModelResponse):
             assert message.vendor_details is None
+
+
+async def test_response_with_thought_part(get_gemini_client: GetGeminiClient):
+    """Tests that a response containing a 'thought' part can be parsed."""
+    content_with_thought = _GeminiContent(
+        role='model',
+        parts=[
+            _GeminiThoughtPart(thought=True, thought_signature='test-signature-value'),
+            _GeminiTextPart(text='Hello from thought test'),
+        ],
+    )
+    response = gemini_response(content_with_thought)
+    gemini_client = get_gemini_client(response)
+    m = GeminiModel('gemini-1.5-flash', provider=GoogleGLAProvider(http_client=gemini_client))
+    agent = Agent(m)
+
+    result = await agent.run('Test with thought')
+
+    assert result.output == 'Hello from thought test'
+    assert result.usage() == snapshot(Usage(requests=1, request_tokens=1, response_tokens=2, total_tokens=3))

{pydantic_ai-0.2.12 → pydantic_ai-0.2.14}/tests/models/test_openai.py

@@ -1710,3 +1710,25 @@ def test_model_profile_strict_not_supported():
             },
         }
     )
+
+
+@pytest.mark.vcr
+async def test_compatible_api_with_tool_calls_without_id(allow_model_requests: None, gemini_api_key: str):
+    provider = OpenAIProvider(
+        openai_client=AsyncOpenAI(
+            base_url='https://generativelanguage.googleapis.com/v1beta/openai/',
+            api_key=gemini_api_key,
+        )
+    )
+
+    model = OpenAIModel('gemini-2.5-pro-preview-05-06', provider=provider)
+
+    agent = Agent(model)
+
+    @agent.tool_plain
+    def get_current_time() -> str:
+        """Get the current time."""
+        return 'Noon'
+
+    response = await agent.run('What is the current time?')
+    assert response.output == snapshot('The current time is Noon.')

{pydantic_ai-0.2.12 → pydantic_ai-0.2.14}/tests/test_agent.py

@@ -2573,3 +2573,47 @@ def test_agent_repr() -> None:
     assert repr(agent) == snapshot(
         "Agent(model=None, name=None, end_strategy='early', model_settings=None, output_type=<class 'str'>, instrument=None)"
     )
+
+
+def test_tool_call_with_validation_value_error_serializable():
+    def llm(messages: list[ModelMessage], info: AgentInfo) -> ModelResponse:
+        if len(messages) == 1:
+            return ModelResponse(parts=[ToolCallPart('foo_tool', {'bar': 0})])
+        elif len(messages) == 3:
+            return ModelResponse(parts=[ToolCallPart('foo_tool', {'bar': 1})])
+        else:
+            return ModelResponse(parts=[TextPart('Tool returned 1')])
+
+    agent = Agent(FunctionModel(llm))
+
+    class Foo(BaseModel):
+        bar: int
+
+        @field_validator('bar')
+        def validate_bar(cls, v: int) -> int:
+            if v == 0:
+                raise ValueError('bar cannot be 0')
+            return v
+
+    @agent.tool_plain
+    def foo_tool(foo: Foo) -> int:
+        return foo.bar
+
+    result = agent.run_sync('Hello')
+    assert json.loads(result.all_messages_json())[2] == snapshot(
+        {
+            'parts': [
+                {
+                    'content': [
+                        {'type': 'value_error', 'loc': ['bar'], 'msg': 'Value error, bar cannot be 0', 'input': 0}
+                    ],
+                    'tool_name': 'foo_tool',
+                    'tool_call_id': IsStr(),
+                    'timestamp': IsStr(),
+                    'part_kind': 'retry-prompt',
+                }
+            ],
+            'instructions': None,
+            'kind': 'request',
+        }
+    )

{pydantic_ai-0.2.12 → pydantic_ai-0.2.14}/tests/test_mcp.py

@@ -1,7 +1,6 @@
 """Tests for the MCP (Model Context Protocol) server implementation."""
 
 import re
-from datetime import timedelta
 from pathlib import Path
 
 import pytest
@@ -71,40 +70,25 @@ async def test_stdio_server_with_cwd():
         assert len(tools) == 10
 
 
-def test_http_server():
-    http_server = MCPServerHTTP(url='http://localhost:8000/sse')
-    assert http_server.url == 'http://localhost:8000/sse'
-    assert http_server._get_log_level() is None  # pyright: ignore[reportPrivateUsage]
+def test_sse_server():
+    sse_server = MCPServerHTTP(url='http://localhost:8000/sse')
+    assert sse_server.url == 'http://localhost:8000/sse'
+    assert sse_server._get_log_level() is None  # pyright: ignore[reportPrivateUsage]
 
 
-def test_http_server_with_header_and_timeout():
-    http_server = MCPServerHTTP(
+def test_sse_server_with_header_and_timeout():
+    sse_server = MCPServerHTTP(
         url='http://localhost:8000/sse',
         headers={'my-custom-header': 'my-header-value'},
         timeout=10,
         sse_read_timeout=100,
         log_level='info',
     )
-    assert http_server.url == 'http://localhost:8000/sse'
-    assert http_server.headers is not None and http_server.headers['my-custom-header'] == 'my-header-value'
-    assert http_server.timeout == 10
-    assert http_server.sse_read_timeout == 100
-    assert http_server._get_log_level() == 'info'  # pyright: ignore[reportPrivateUsage]
-
-
-def test_http_server_with_timedelta_arguments():
-    http_server = MCPServerHTTP(
-        url='http://localhost:8000/sse',
-        headers={'my-custom-header': 'my-header-value'},
-        timeout=timedelta(seconds=10),  # type: ignore[arg-type]
-        sse_read_timeout=timedelta(seconds=100),  # type: ignore[arg-type]
-        log_level='info',
-    )
-    assert http_server.url == 'http://localhost:8000/sse'
-    assert http_server.headers is not None and http_server.headers['my-custom-header'] == 'my-header-value'
-    assert http_server.timeout == 10
-    assert http_server.sse_read_timeout == 100
-    assert http_server._get_log_level() == 'info'  # pyright: ignore[reportPrivateUsage]
+    assert sse_server.url == 'http://localhost:8000/sse'
+    assert sse_server.headers is not None and sse_server.headers['my-custom-header'] == 'my-header-value'
+    assert sse_server.timeout == 10
+    assert sse_server.sse_read_timeout == 100
+    assert sse_server._get_log_level() == 'info'  # pyright: ignore[reportPrivateUsage]
 
 
 @pytest.mark.vcr()