Add genai.errors handling in GoogleModel

- Add error handling helper method `_handle_google_error`
- Convert Google API errors to ModelHTTPError with proper status codes
- Map specific function-related errors (400-level) appropriately
- Keep original error details in response body
- Add test cases for API error handling

Resolves: #3088

Author: timothy-jeong

pydantic_ai_slim/pydantic_ai/models/google.py

@@ -14,7 +14,7 @@
 from .._output import OutputObjectDefinition
 from .._run_context import RunContext
 from ..builtin_tools import CodeExecutionTool, ImageGenerationTool, UrlContextTool, WebSearchTool
-from ..exceptions import UserError
+from ..exceptions import ModelHTTPError, UserError
 from ..messages import (
     BinaryContent,
     BuiltinToolCallPart,
@@ -50,7 +50,7 @@
 )
 
 try:
-    from google.genai import Client
+    from google.genai import Client, errors
     from google.genai.types import (
         BlobDict,
         CodeExecutionResult,
@@ -357,6 +357,37 @@ def _get_tool_config(
         else:
             return None
 
+    def _handle_google_error(self, error: Exception) -> ModelHTTPError:
+        """Helper method to convert Google API errors to ModelHTTPError."""
+        if isinstance(error, errors.APIError):
+            return ModelHTTPError(
+                status_code=getattr(error, 'code', 500),
+                model_name=self._model_name,
+                body=error.details,
+            )
+            
+        error_mappings = {
+            errors.UnknownFunctionCallArgumentError: (400, 'the function call argument cannot be converted to the parameter annotation.', 'BAD_REQUEST'),
+            errors.UnsupportedFunctionError: (404, 'the function is not supported.', 'NOT_FOUND'),
+            errors.FunctionInvocationError: (400, 'the function cannot be invoked with the given arguments.', 'BAD_REQUEST'),
+            errors.UnknownApiResponseError: (422, 'the response from the API cannot be parsed as JSON.', 'UNPROCESSABLE_CONTENT')
+        }
+            
+        if error.__class__ in error_mappings:
+            code, message, status = error_mappings[error.__class__]
+            return ModelHTTPError(
+                status_code=code,
+                model_name=self._model_name,
+                body={'error': {'code': code, 'message': message, 'status': status}}
+            )
+                
+        # Handle unknown errors as 500 Internal Server Error
+        return ModelHTTPError(
+            status_code=500,
+            model_name=self._model_name,
+            body={'error': {'code': 500, 'message': str(error), 'status': 'INTERNAL_ERROR'}}
+        )
+        
     @overload
     async def _generate_content(
         self,
@@ -384,7 +415,16 @@ async def _generate_content(
     ) -> GenerateContentResponse | Awaitable[AsyncIterator[GenerateContentResponse]]:
         contents, config = await self._build_content_and_config(messages, model_settings, model_request_parameters)
         func = self.client.aio.models.generate_content_stream if stream else self.client.aio.models.generate_content
-        return await func(model=self._model_name, contents=contents, config=config)  # type: ignore
+        try:
+            return await func(model=self._model_name, contents=contents, config=config)  # type: ignore
+        except (
+            errors.APIError,
+            errors.UnknownFunctionCallArgumentError,
+            errors.UnsupportedFunctionError,
+            errors.FunctionInvocationError,
+            errors.UnknownApiResponseError
+        ) as e:
+            raise self._handle_google_error(e) from e
 
     async def _build_content_and_config(
         self,

tests/models/test_google.py

@@ -9,6 +9,7 @@
 from httpx import Timeout
 from inline_snapshot import Is, snapshot
 from pydantic import BaseModel
+from pytest_mock import MockerFixture
 from typing_extensions import TypedDict
 
 from pydantic_ai import (
@@ -41,7 +42,7 @@
 )
 from pydantic_ai.agent import Agent
 from pydantic_ai.builtin_tools import CodeExecutionTool, ImageGenerationTool, UrlContextTool, WebSearchTool
-from pydantic_ai.exceptions import ModelRetry, UnexpectedModelBehavior, UserError
+from pydantic_ai.exceptions import ModelHTTPError, ModelRetry, UnexpectedModelBehavior, UserError
 from pydantic_ai.messages import (
     BuiltinToolCallEvent,  # pyright: ignore[reportDeprecated]
     BuiltinToolResultEvent,  # pyright: ignore[reportDeprecated]
@@ -54,6 +55,7 @@
 from ..parts_from_messages import part_types_from_messages
 
 with try_import() as imports_successful:
+    from google.genai import errors
     from google.genai.types import (
         GenerateContentResponse,
         GenerateContentResponseUsageMetadata,
@@ -2929,3 +2931,96 @@ async def test_google_vertexai_image_generation(allow_model_requests: None, vert
             identifier='f3edd8',
         )
     )
+
+
+# API 에러 테스트 데이터
+@pytest.mark.parametrize(
+    'error_class,error_response,expected_status',
+    [(
+        errors.ServerError,
+        {
+            'error': {
+                'code': 503,
+                'message': 'The service is currently unavailable.',
+                'status': 'UNAVAILABLE'
+            }
+        },
+        503
+    ),
+    (
+        errors.ClientError,
+        {
+            'error': {
+                'code': 400,
+                'message': 'Invalid request parameters',
+                'status': 'INVALID_ARGUMENT'
+            }
+        },
+        400
+    ),
+    (
+        errors.ClientError,
+        {
+            'error': {
+                'code': 429,
+                'message': 'Rate limit exceeded',
+                'status': 'RESOURCE_EXHAUSTED'
+            }
+        },
+        429
+    ),
+])
+async def test_google_api_errors_are_handled(
+    allow_model_requests: None,
+    google_provider: GoogleProvider,
+    mocker: MockerFixture,
+    error_class: type[errors.APIError],
+    error_response: dict,
+    expected_status: int,
+):
+    model = GoogleModel('gemini-1.5-flash', provider=google_provider)
+    mocked_error = error_class(expected_status, error_response)
+    mocker.patch.object(
+        model.client.aio.models,
+        'generate_content',
+        side_effect=mocked_error
+    )
+    
+    agent = Agent(model=model)
+    
+    with pytest.raises(ModelHTTPError) as exc_info:
+        await agent.run('This prompt will trigger the mocked error.')
+        
+    assert exc_info.value.status_code == expected_status
+    assert error_response['error']['message'] in str(exc_info.value.body)
+
+
+@pytest.mark.parametrize(
+    'error_class,expected_status', 
+    [
+        (errors.UnknownFunctionCallArgumentError, 400),
+        (errors.UnsupportedFunctionError, 404),
+        (errors.FunctionInvocationError, 400),
+        (errors.UnknownApiResponseError, 422),
+])
+async def test_google_specific_errors_are_handled(
+    allow_model_requests: None,
+    google_provider: GoogleProvider,
+    mocker: MockerFixture,
+    error_class: type[errors.APIError],
+    expected_status: int,
+):
+    
+    model = GoogleModel('gemini-1.5-flash', provider=google_provider)
+    mocked_error = error_class
+    mocker.patch.object(
+        model.client.aio.models,
+        'generate_content',
+        side_effect=mocked_error
+    )
+    
+    agent = Agent(model=model)
+    
+    with pytest.raises(ModelHTTPError) as exc_info:
+        await agent.run('This prompt will trigger the mocked error.')
+    assert exc_info.value.status_code == expected_status