Litellm gemini cli bug fix (#14451)

* Fix gemini cli error

* Add reasoning request support

* Added better handling

* remove other PR code

* refactored code for better structure following

---------

Co-authored-by: [email protected] <[email protected]>

Author: kankute-sameer

litellm/google_genai/main.py

@@ -224,6 +224,9 @@ async def agenerate_content(
         loop = asyncio.get_event_loop()
         kwargs["agenerate_content"] = True
 
+        # Handle generationConfig parameter from kwargs for backward compatibility
+        if "generationConfig" in kwargs and config is None:
+            config = kwargs.pop("generationConfig")
         # get custom llm provider so we can use this for mapping exceptions
         if custom_llm_provider is None:
             _, custom_llm_provider, _, _ = litellm.get_llm_provider(
@@ -288,6 +291,9 @@ def generate_content(
     try:
         _is_async = kwargs.pop("agenerate_content", False) is True
 
+        # Handle generationConfig parameter from kwargs for backward compatibility
+        if "generationConfig" in kwargs and config is None:
+            config = kwargs.pop("generationConfig")
         # Check for mock response first
         litellm_params = GenericLiteLLMParams(**kwargs)
         if litellm_params.mock_response and isinstance(
@@ -374,6 +380,9 @@ async def agenerate_content_stream(
     try:
         kwargs["agenerate_content_stream"] = True
 
+        # Handle generationConfig parameter from kwargs for backward compatibility
+        if "generationConfig" in kwargs and config is None:
+            config = kwargs.pop("generationConfig")
         # get custom llm provider so we can use this for mapping exceptions
         if custom_llm_provider is None:
             _, custom_llm_provider, _, _ = litellm.get_llm_provider(
@@ -461,6 +470,9 @@ def generate_content_stream(
         # Remove any async-related flags since this is the sync function
         _is_async = kwargs.pop("agenerate_content_stream", False)
 
+        # Handle generationConfig parameter from kwargs for backward compatibility
+        if "generationConfig" in kwargs and config is None:
+            config = kwargs.pop("generationConfig")
         # Setup the call
         setup_result = GenerateContentHelper.setup_generate_content_call(
             model=model,

litellm/llms/gemini/count_tokens/handler.py

@@ -136,4 +136,3 @@ async def acount_tokens(
         except Exception as e:
             error_msg = f"Unexpected error during token counting: {str(e)}"
             raise Exception(error_msg) from e
-

litellm/llms/vertex_ai/google_genai/transformation.py

@@ -1,7 +1,7 @@
 """
 Transformation for Calling Google models in their native format.
 """
-from typing import Literal, Optional, Union
+from typing import Dict, Literal, Optional, Union
 
 from litellm.llms.gemini.google_genai.transformation import GoogleGenAIConfig
 from litellm.types.router import GenericLiteLLMParams
@@ -11,20 +11,20 @@ class VertexAIGoogleGenAIConfig(GoogleGenAIConfig):
     """
     Configuration for calling Google models in their native format.
     """
+
     HEADER_NAME = "Authorization"
     BEARER_PREFIX = "Bearer"
-    
+
     @property
     def custom_llm_provider(self) -> Literal["gemini", "vertex_ai"]:
         return "vertex_ai"
-    
 
     def validate_environment(
-        self, 
+        self,
         api_key: Optional[str],
         headers: Optional[dict],
         model: str,
-        litellm_params: Optional[Union[GenericLiteLLMParams, dict]]
+        litellm_params: Optional[Union[GenericLiteLLMParams, dict]],
     ) -> dict:
         default_headers = {
             "Content-Type": "application/json",
@@ -36,4 +36,65 @@ def validate_environment(
             default_headers.update(headers)
 
         return default_headers
-    
+
+    def _camel_to_snake(self, camel_str: str) -> str:
+        """Convert camelCase to snake_case"""
+        import re
+
+        return re.sub(r"(?<!^)(?=[A-Z])", "_", camel_str).lower()
+
+    def map_generate_content_optional_params(
+        self,
+        generate_content_config_dict,
+        model: str,
+    ):
+        """
+        Map Google GenAI parameters to provider-specific format.
+
+        Args:
+            generate_content_optional_params: Optional parameters for generate content
+            model: The model name
+
+        Returns:
+            Mapped parameters for the provider
+        """
+        from litellm.types.google_genai.main import GenerateContentConfigDict
+
+        _generate_content_config_dict = GenerateContentConfigDict()
+
+        for param, value in generate_content_config_dict.items():
+            camel_case_key = self._camel_to_snake(param)
+            _generate_content_config_dict[camel_case_key] = value
+        return dict(_generate_content_config_dict)
+
+    def transform_generate_content_request(
+        self,
+        model: str,
+        contents: any,
+        tools: Optional[any],
+        generate_content_config_dict: Dict,
+        system_instruction: Optional[any] = None,
+    ) -> dict:
+        """
+        Transform the generate content request for Vertex AI.
+        Since Vertex AI natively supports Google GenAI format, we can pass most fields directly.
+        """
+        # Build the request in Google GenAI format that Vertex AI expects
+        result = {
+            "model": model,
+            "contents": contents,
+        }
+
+        # Add tools if provided
+        if tools:
+            result["tools"] = tools
+
+        # Add systemInstruction if provided
+        if system_instruction:
+            result["systemInstruction"] = system_instruction
+
+        # Handle generationConfig - Vertex AI expects it in the same format
+        if generate_content_config_dict:
+            result["generationConfig"] = generate_content_config_dict
+
+        return result

litellm/proxy/route_llm_request.py

@@ -85,6 +85,7 @@ async def route_request(
     """
     team_id = get_team_id_from_data(data)
     router_model_names = llm_router.model_names if llm_router is not None else []
+
     if "api_key" in data or "api_base" in data:
         if llm_router is not None:
             return getattr(llm_router, f"{route_type}")(**data)
@@ -123,24 +124,20 @@ async def route_request(
             data["model"] in router_model_names
             or data["model"] in llm_router.get_model_ids()
         ):
-
             return getattr(llm_router, f"{route_type}")(**data)
 
         elif (
             llm_router.model_group_alias is not None
             and data["model"] in llm_router.model_group_alias
         ):
-
             return getattr(llm_router, f"{route_type}")(**data)
 
         elif data["model"] in llm_router.deployment_names:
-
             return getattr(llm_router, f"{route_type}")(
                 **data, specific_deployment=True
             )
 
         elif data["model"] not in router_model_names:
-
             if llm_router.router_general_settings.pass_through_all_models:
                 return getattr(litellm, f"{route_type}")(**data)
             elif (
@@ -162,7 +159,6 @@ async def route_request(
     elif user_model is not None:
         return getattr(litellm, f"{route_type}")(**data)
     elif route_type == "allm_passthrough_route":
-
         return getattr(litellm, f"{route_type}")(**data)
 
     # if no route found then it's a bad request