Refactor: simplify ModelHTTPError handling

- Align with other model implementations (openai, groq) by removing unnecessary error transformation logic
- Remove redundant error handling test cases

Resolves: #3088

Author: timothy-jeong

pydantic_ai_slim/pydantic_ai/models/google.py

@@ -357,49 +357,6 @@ 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,
@@ -429,14 +386,10 @@ async def _generate_content(
         func = self.client.aio.models.generate_content_stream if stream else self.client.aio.models.generate_content
         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
+        except errors.APIError as e:
+            if (status_code := e.code) >= 400:
+                raise ModelHTTPError(status_code=status_code, model_name=self._model_name, body=e.details) from e
+            raise  # pragma: lax no cover
 
     async def _build_content_and_config(
         self,

tests/models/test_google.py

@@ -2933,7 +2933,6 @@ async def test_google_vertexai_image_generation(allow_model_requests: None, vert
     )
 
 
-# API 에러 테스트 데이터
 @pytest.mark.parametrize(
     'error_class,error_response,expected_status',
     [
@@ -2954,7 +2953,7 @@ async def test_google_vertexai_image_generation(allow_model_requests: None, vert
         ),
     ],
 )
-async def test_google_api_errors_are_handled(
+async def test_model_status_error(
     allow_model_requests: None,
     google_provider: GoogleProvider,
     mocker: MockerFixture,
@@ -2973,30 +2972,3 @@ async def test_google_api_errors_are_handled(
 
     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