fix(litellm): coerce tool_choice to None when tools is empty

LiteLLM rejects tool_choice="required"/"none" when the tools list is
falsy. tool_choice and tools were derived from independent config fields
with no cross-check, so a caller setting mode=ANY with no
function_declarations would reach acompletion() with tools=None and
tool_choice="required".

Add a guard in _get_completion_inputs to coerce tool_choice to None
when tools is falsy, and mirror the same coercion in
generate_content_async after the "functions" additional-arg override
that already nulls tools.

Add two tests covering both paths; update four existing tool_choice
tests to include a FunctionDeclaration so they remain valid under the
new guard.

Author: ecanlar

src/google/adk/models/lite_llm.py

@@ -2081,6 +2081,11 @@ async def _get_completion_inputs(
       tool_choice = "none"
     # AUTO → None (provider default)
 
+  # Coerce tool_choice to None when there are no tools to choose from.
+  # LiteLLM rejects tool_choice="required" (or "none") when tools is falsy.
+  if not tools:
+    tool_choice = None
+
   return messages, tools, response_format, generation_params, tool_choice
 
 
@@ -2354,6 +2359,8 @@ async def generate_content_async(
     if "functions" in self._additional_args:
       # LiteLLM does not support both tools and functions together.
       tools = None
+      # Without tools, tool_choice ("required"/"none") would be rejected by LiteLLM.
+      tool_choice = None
 
     completion_args = {
         "model": effective_model,

tests/unittests/models/test_litellm.py

@@ -5135,17 +5135,24 @@ async def test_get_completion_inputs_tool_choice_none_without_tool_config():
 
 @pytest.mark.asyncio
 async def test_get_completion_inputs_tool_choice_required_for_any_mode():
-  """tool_choice must be 'required' when mode=ANY."""
+  """tool_choice must be 'required' when mode=ANY and tools are present."""
   llm_request = LlmRequest(
       contents=[
           types.Content(role="user", parts=[types.Part.from_text(text="Hello")])
       ],
       config=types.GenerateContentConfig(
+          tools=[
+              types.Tool(
+                  function_declarations=[
+                      types.FunctionDeclaration(name="my_func", description="A func")
+                  ]
+              )
+          ],
           tool_config=types.ToolConfig(
               function_calling_config=types.FunctionCallingConfig(
                   mode=types.FunctionCallingConfigMode.ANY
               )
-          )
+          ),
       ),
   )
 
@@ -5158,17 +5165,24 @@ async def test_get_completion_inputs_tool_choice_required_for_any_mode():
 
 @pytest.mark.asyncio
 async def test_get_completion_inputs_tool_choice_none_for_none_mode():
-  """tool_choice must be 'none' when mode=NONE."""
+  """tool_choice must be 'none' when mode=NONE and tools are present."""
   llm_request = LlmRequest(
       contents=[
           types.Content(role="user", parts=[types.Part.from_text(text="Hello")])
       ],
       config=types.GenerateContentConfig(
+          tools=[
+              types.Tool(
+                  function_declarations=[
+                      types.FunctionDeclaration(name="my_func", description="A func")
+                  ]
+              )
+          ],
           tool_config=types.ToolConfig(
               function_calling_config=types.FunctionCallingConfig(
                   mode=types.FunctionCallingConfigMode.NONE
               )
-          )
+          ),
       ),
   )
 
@@ -5206,7 +5220,7 @@ async def test_get_completion_inputs_tool_choice_none_for_auto_mode():
 async def test_generate_content_async_propagates_tool_choice_required(
     mock_acompletion, mock_completion
 ):
-  """generate_content_async must pass tool_choice='required' to acompletion."""
+  """generate_content_async must pass tool_choice='required' to acompletion when tools are present."""
   llm_client = MockLLMClient(mock_acompletion, mock_completion)
   lite_llm_instance = LiteLlm(model="openai/gpt-4o", llm_client=llm_client)
 
@@ -5217,11 +5231,18 @@ async def test_generate_content_async_propagates_tool_choice_required(
           )
       ],
       config=types.GenerateContentConfig(
+          tools=[
+              types.Tool(
+                  function_declarations=[
+                      types.FunctionDeclaration(name="my_func", description="A func")
+                  ]
+              )
+          ],
           tool_config=types.ToolConfig(
               function_calling_config=types.FunctionCallingConfig(
                   mode=types.FunctionCallingConfigMode.ANY
               )
-          )
+          ),
       ),
   )
 
@@ -5237,7 +5258,7 @@ async def test_generate_content_async_propagates_tool_choice_required(
 async def test_generate_content_async_propagates_tool_choice_none_mode(
     mock_acompletion, mock_completion
 ):
-  """generate_content_async must pass tool_choice='none' to acompletion for NONE mode."""
+  """generate_content_async must pass tool_choice='none' to acompletion for NONE mode when tools are present."""
   llm_client = MockLLMClient(mock_acompletion, mock_completion)
   lite_llm_instance = LiteLlm(model="openai/gpt-4o", llm_client=llm_client)
 
@@ -5248,11 +5269,18 @@ async def test_generate_content_async_propagates_tool_choice_none_mode(
           )
       ],
       config=types.GenerateContentConfig(
+          tools=[
+              types.Tool(
+                  function_declarations=[
+                      types.FunctionDeclaration(name="my_func", description="A func")
+                  ]
+              )
+          ],
           tool_config=types.ToolConfig(
               function_calling_config=types.FunctionCallingConfig(
                   mode=types.FunctionCallingConfigMode.NONE
               )
-          )
+          ),
       ),
   )
 
@@ -5313,3 +5341,63 @@ async def test_generate_content_async_omits_tool_choice_without_tool_config(
   mock_acompletion.assert_called_once()
   _, kwargs = mock_acompletion.call_args
   assert "tool_choice" not in kwargs
+
+
+@pytest.mark.asyncio
+async def test_get_completion_inputs_tool_choice_coerced_to_none_when_no_tools():
+  """tool_choice must be coerced to None when mode=ANY but no function_declarations exist."""
+  llm_request = LlmRequest(
+      contents=[
+          types.Content(role="user", parts=[types.Part.from_text(text="Hello")])
+      ],
+      config=types.GenerateContentConfig(
+          tool_config=types.ToolConfig(
+              function_calling_config=types.FunctionCallingConfig(
+                  mode=types.FunctionCallingConfigMode.ANY
+              )
+          )
+      ),
+  )
+
+  _, tools, _, _, tool_choice = await _get_completion_inputs(
+      llm_request, model="openai/gpt-4o"
+  )
+
+  assert not tools
+  assert tool_choice is None
+
+
+@pytest.mark.asyncio
+async def test_generate_content_async_omits_tool_choice_when_functions_override(
+    mock_acompletion, mock_completion
+):
+  """When `functions` is passed as an additional kwarg, tools is nulled and tool_choice must also be dropped."""
+  llm_client = MockLLMClient(mock_acompletion, mock_completion)
+  lite_llm_instance = LiteLlm(
+      model="openai/gpt-4o",
+      llm_client=llm_client,
+      functions=[{"name": "noop", "parameters": {"type": "object"}}],
+  )
+
+  llm_request = LlmRequest(
+      contents=[
+          types.Content(
+              role="user", parts=[types.Part.from_text(text="Call something")]
+          )
+      ],
+      config=types.GenerateContentConfig(
+          tool_config=types.ToolConfig(
+              function_calling_config=types.FunctionCallingConfig(
+                  mode=types.FunctionCallingConfigMode.ANY
+              )
+          )
+      ),
+  )
+
+  async for _ in lite_llm_instance.generate_content_async(llm_request):
+    pass
+
+  mock_acompletion.assert_called_once()
+  _, kwargs = mock_acompletion.call_args
+  assert kwargs.get("tools") is None
+  assert "tool_choice" not in kwargs