Merge branch 'main' into mcp-json-env-vars

Author: wgillett

.github/workflows/ci.yml

@@ -80,7 +80,7 @@ jobs:
       - run: make docs
 
       - run: make docs-insiders
-        if: github.event.pull_request.head.repo.full_name == github.repository || github.ref == 'refs/heads/main'
+        if: (github.event.pull_request.head.repo.full_name == github.repository || github.ref == 'refs/heads/main') && github.repository == 'pydantic/pydantic-ai'
         env:
           PPPR_TOKEN: ${{ secrets.PPPR_TOKEN }}
 
@@ -103,7 +103,7 @@ jobs:
   test-live:
     runs-on: ubuntu-latest
     timeout-minutes: 5
-    if: github.event.pull_request.head.repo.full_name == github.repository || github.event_name == 'push'
+    if: (github.event.pull_request.head.repo.full_name == github.repository || github.event_name == 'push') && github.repository == 'pydantic/pydantic-ai'
     steps:
       - uses: actions/checkout@v4
 

.gitignore

@@ -21,3 +21,5 @@ node_modules/
 /test_tmp/
 .mcp.json
 .claude/
+/.cursor/
+/.devcontainer/

pydantic_ai_slim/pydantic_ai/exceptions.py

@@ -44,6 +44,9 @@ def __init__(self, message: str):
     def __eq__(self, other: Any) -> bool:
         return isinstance(other, self.__class__) and other.message == self.message
 
+    def __hash__(self) -> int:
+        return hash((self.__class__, self.message))
+
     @classmethod
     def __get_pydantic_core_schema__(cls, _: Any, __: Any) -> core_schema.CoreSchema:
         """Pydantic core schema to allow `ModelRetry` to be (de)serialized."""

pydantic_ai_slim/pydantic_ai/messages.py

@@ -776,10 +776,11 @@ def model_response_str(self) -> str:
     def model_response_object(self) -> dict[str, Any]:
         """Return a dictionary representation of the content, wrapping non-dict types appropriately."""
         # gemini supports JSON dict return values, but no other JSON types, hence we wrap anything else in a dict
-        if isinstance(self.content, dict):
-            return tool_return_ta.dump_python(self.content, mode='json')  # pyright: ignore[reportUnknownMemberType]
+        json_content = tool_return_ta.dump_python(self.content, mode='json')
+        if isinstance(json_content, dict):
+            return json_content  # type: ignore[reportUnknownReturn]
         else:
-            return {'return_value': tool_return_ta.dump_python(self.content, mode='json')}
+            return {'return_value': json_content}
 
     def otel_event(self, settings: InstrumentationSettings) -> Event:
         return Event(

pydantic_ai_slim/pydantic_ai/models/google.py

@@ -677,13 +677,18 @@ async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
                         provider_name=self.provider_name,
                     )
 
-                if part.text:
-                    if part.thought:
-                        yield self._parts_manager.handle_thinking_delta(vendor_part_id='thinking', content=part.text)
-                    else:
-                        maybe_event = self._parts_manager.handle_text_delta(vendor_part_id='content', content=part.text)
-                        if maybe_event is not None:  # pragma: no branch
-                            yield maybe_event
+                if part.text is not None:
+                    if len(part.text) > 0:
+                        if part.thought:
+                            yield self._parts_manager.handle_thinking_delta(
+                                vendor_part_id='thinking', content=part.text
+                            )
+                        else:
+                            maybe_event = self._parts_manager.handle_text_delta(
+                                vendor_part_id='content', content=part.text
+                            )
+                            if maybe_event is not None:  # pragma: no branch
+                                yield maybe_event
                 elif part.function_call:
                     maybe_event = self._parts_manager.handle_tool_call_delta(
                         vendor_part_id=uuid4(),
@@ -822,7 +827,10 @@ def _process_response_from_parts(
         elif part.code_execution_result is not None:
             assert code_execution_tool_call_id is not None
             item = _map_code_execution_result(part.code_execution_result, provider_name, code_execution_tool_call_id)
-        elif part.text:
+        elif part.text is not None:
+            # Google sometimes sends empty text parts, we don't want to add them to the response
+            if len(part.text) == 0:
+                continue
             if part.thought:
                 item = ThinkingPart(content=part.text)
             else:

pydantic_ai_slim/pydantic_ai/ui/vercel_ai/_event_stream.py

@@ -9,6 +9,7 @@
 from pydantic_core import to_json
 
 from ...messages import (
+    BaseToolReturnPart,
     BuiltinToolCallPart,
     BuiltinToolReturnPart,
     FilePart,
@@ -155,21 +156,23 @@ async def handle_tool_call_delta(self, delta: ToolCallPartDelta) -> AsyncIterato
         )
 
     async def handle_tool_call_end(self, part: ToolCallPart) -> AsyncIterator[BaseChunk]:
-        yield ToolInputAvailableChunk(tool_call_id=part.tool_call_id, tool_name=part.tool_name, input=part.args)
+        yield ToolInputAvailableChunk(
+            tool_call_id=part.tool_call_id, tool_name=part.tool_name, input=part.args_as_dict()
+        )
 
     async def handle_builtin_tool_call_end(self, part: BuiltinToolCallPart) -> AsyncIterator[BaseChunk]:
         yield ToolInputAvailableChunk(
             tool_call_id=part.tool_call_id,
             tool_name=part.tool_name,
-            input=part.args,
+            input=part.args_as_dict(),
             provider_executed=True,
             provider_metadata={'pydantic_ai': {'provider_name': part.provider_name}},
         )
 
     async def handle_builtin_tool_return(self, part: BuiltinToolReturnPart) -> AsyncIterator[BaseChunk]:
         yield ToolOutputAvailableChunk(
             tool_call_id=part.tool_call_id,
-            output=part.content,
+            output=self._tool_return_output(part),
             provider_executed=True,
         )
 
@@ -178,10 +181,15 @@ async def handle_file(self, part: FilePart) -> AsyncIterator[BaseChunk]:
         yield FileChunk(url=file.data_uri, media_type=file.media_type)
 
     async def handle_function_tool_result(self, event: FunctionToolResultEvent) -> AsyncIterator[BaseChunk]:
-        result = event.result
-        if isinstance(result, RetryPromptPart):
-            yield ToolOutputErrorChunk(tool_call_id=result.tool_call_id, error_text=result.model_response())
+        part = event.result
+        if isinstance(part, RetryPromptPart):
+            yield ToolOutputErrorChunk(tool_call_id=part.tool_call_id, error_text=part.model_response())
         else:
-            yield ToolOutputAvailableChunk(tool_call_id=result.tool_call_id, output=result.content)
+            yield ToolOutputAvailableChunk(tool_call_id=part.tool_call_id, output=self._tool_return_output(part))
 
         # ToolCallResultEvent.content may hold user parts (e.g. text, images) that Vercel AI does not currently have events for
+
+    def _tool_return_output(self, part: BaseToolReturnPart) -> Any:
+        output = part.model_response_object()
+        # Unwrap the return value from the output dictionary if it exists
+        return output.get('return_value', output)

tests/models/test_google.py

@@ -3,6 +3,7 @@
 import datetime
 import os
 import re
+from collections.abc import AsyncIterator
 from typing import Any
 
 import pytest
@@ -47,6 +48,7 @@
     BuiltinToolCallEvent,  # pyright: ignore[reportDeprecated]
     BuiltinToolResultEvent,  # pyright: ignore[reportDeprecated]
 )
+from pydantic_ai.models import ModelRequestParameters
 from pydantic_ai.output import NativeOutput, PromptedOutput, TextOutput, ToolOutput
 from pydantic_ai.settings import ModelSettings
 from pydantic_ai.usage import RequestUsage, RunUsage, UsageLimits
@@ -56,6 +58,7 @@
 
 with try_import() as imports_successful:
     from google.genai.types import (
+        FinishReason as GoogleFinishReason,
         GenerateContentResponse,
         GenerateContentResponseUsageMetadata,
         HarmBlockThreshold,
@@ -64,7 +67,12 @@
         ModalityTokenCount,
     )
 
-    from pydantic_ai.models.google import GoogleModel, GoogleModelSettings, _metadata_as_usage  # type: ignore
+    from pydantic_ai.models.google import (
+        GeminiStreamedResponse,
+        GoogleModel,
+        GoogleModelSettings,
+        _metadata_as_usage,  # pyright: ignore[reportPrivateUsage]
+    )
     from pydantic_ai.models.openai import OpenAIResponsesModel, OpenAIResponsesModelSettings
     from pydantic_ai.providers.google import GoogleProvider
     from pydantic_ai.providers.openai import OpenAIProvider
@@ -3063,3 +3071,52 @@ async def test_google_httpx_client_is_not_closed(allow_model_requests: None, gem
     agent = Agent(GoogleModel('gemini-2.5-flash-lite', provider=GoogleProvider(api_key=gemini_api_key)))
     result = await agent.run('What is the capital of Mexico?')
     assert result.output == snapshot('The capital of Mexico is **Mexico City**.')
+
+
+def test_google_process_response_filters_empty_text_parts(google_provider: GoogleProvider):
+    model = GoogleModel('gemini-2.5-pro', provider=google_provider)
+    response = _generate_response_with_texts(response_id='resp-123', texts=['', 'first', '', 'second'])
+
+    result = model._process_response(response)  # pyright: ignore[reportPrivateUsage]
+
+    assert result.parts == snapshot([TextPart(content='first'), TextPart(content='second')])
+
+
+async def test_gemini_streamed_response_emits_text_events_for_non_empty_parts():
+    chunk = _generate_response_with_texts('stream-1', ['', 'streamed text'])
+
+    async def response_iterator() -> AsyncIterator[GenerateContentResponse]:
+        yield chunk
+
+    streamed_response = GeminiStreamedResponse(
+        model_request_parameters=ModelRequestParameters(),
+        _model_name='gemini-test',
+        _response=response_iterator(),
+        _timestamp=datetime.datetime.now(datetime.timezone.utc),
+        _provider_name='test-provider',
+    )
+
+    events = [event async for event in streamed_response._get_event_iterator()]  # pyright: ignore[reportPrivateUsage]
+    assert events == snapshot([PartStartEvent(index=0, part=TextPart(content='streamed text'))])
+
+
+def _generate_response_with_texts(response_id: str, texts: list[str]) -> GenerateContentResponse:
+    return GenerateContentResponse.model_validate(
+        {
+            'response_id': response_id,
+            'model_version': 'gemini-test',
+            'usage_metadata': GenerateContentResponseUsageMetadata(
+                prompt_token_count=0,
+                candidates_token_count=0,
+            ),
+            'candidates': [
+                {
+                    'finish_reason': GoogleFinishReason.STOP,
+                    'content': {
+                        'role': 'model',
+                        'parts': [{'text': text} for text in texts],
+                    },
+                }
+            ],
+        }
+    )

tests/test_agent.py

@@ -3724,13 +3724,11 @@ def test_tool_return_part_binary_content_serialization():
 
     assert tool_return.model_response_object() == snapshot(
         {
-            'return_value': {
-                'data': 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYGAAAAAEAAH2FzgAAAAASUVORK5CYII=',
-                'media_type': 'image/png',
-                'vendor_metadata': None,
-                '_identifier': None,
-                'kind': 'binary',
-            }
+            'data': 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYGAAAAAEAAH2FzgAAAAASUVORK5CYII=',
+            'media_type': 'image/png',
+            'vendor_metadata': None,
+            '_identifier': None,
+            'kind': 'binary',
         }
     )
 

tests/test_exceptions.py

@@ -0,0 +1,58 @@
+"""Tests for exception classes."""
+
+from collections.abc import Callable
+from typing import Any
+
+import pytest
+
+from pydantic_ai import ModelRetry
+from pydantic_ai.exceptions import (
+    AgentRunError,
+    ApprovalRequired,
+    CallDeferred,
+    IncompleteToolCall,
+    ModelHTTPError,
+    UnexpectedModelBehavior,
+    UsageLimitExceeded,
+    UserError,
+)
+
+
+@pytest.mark.parametrize(
+    'exc_factory',
+    [
+        lambda: ModelRetry('test'),
+        lambda: CallDeferred(),
+        lambda: ApprovalRequired(),
+        lambda: UserError('test'),
+        lambda: AgentRunError('test'),
+        lambda: UnexpectedModelBehavior('test'),
+        lambda: UsageLimitExceeded('test'),
+        lambda: ModelHTTPError(500, 'model'),
+        lambda: IncompleteToolCall('test'),
+    ],
+    ids=[
+        'ModelRetry',
+        'CallDeferred',
+        'ApprovalRequired',
+        'UserError',
+        'AgentRunError',
+        'UnexpectedModelBehavior',
+        'UsageLimitExceeded',
+        'ModelHTTPError',
+        'IncompleteToolCall',
+    ],
+)
+def test_exceptions_hashable(exc_factory: Callable[[], Any]):
+    """Test that all exception classes are hashable and usable as keys."""
+    exc = exc_factory()
+
+    # Does not raise TypeError
+    _ = hash(exc)
+
+    # Can be used in sets and dicts
+    s = {exc}
+    d = {exc: 'value'}
+
+    assert exc in s
+    assert d[exc] == 'value'