fix: Handle empty message in LiteLLM response

When a turn ends with tool calls only, LiteLLM response may have an empty
message. Previously, this raised a ValueError. This change returns an empty
LlmResponse instead, matching the behavior of the streaming path.

Re-implemented from GitHub PR #3699 to fix issue #3618

Closes #3618
Merge #3699

Co-authored-by: Shangjie Chen <deanchen@google.com>
PiperOrigin-RevId: 938139278

Author: DeanChensj

src/google/adk/models/lite_llm.py

@@ -1793,26 +1793,31 @@ def _model_response_to_generate_content_response(
     message = first_choice.get("message", None)
     finish_reason = first_choice.get("finish_reason", None)
 
-  if not message:
-    raise ValueError("No message in response")
+  # Handle case where message is None or empty (e.g., when the response contains
+  # no text content or tool calls). Create empty LlmResponse instead of raising error.
+  if message:
+    thought_parts = _convert_reasoning_value_to_parts(
+        _extract_reasoning_value(message)
+    )
+    llm_response = _message_to_generate_content_response(
+        message,
+        model_version=response.model,
+        thought_parts=thought_parts or None,
+    )
+  else:
+    # Create empty LlmResponse when message is None or empty
+    llm_response = LlmResponse(
+        content=types.Content(role="model", parts=[]),
+        model_version=response.model,
+    )
 
-  thought_parts = _convert_reasoning_value_to_parts(
-      _extract_reasoning_value(message)
-  )
-  llm_response = _message_to_generate_content_response(
-      message,
-      model_version=response.model,
-      thought_parts=thought_parts or None,
-  )
-  if finish_reason:
-    # If LiteLLM already provides a FinishReason enum (e.g., for Gemini), use
-    # it directly. Otherwise, map the finish_reason string to the enum.
-    if isinstance(finish_reason, types.FinishReason):
-      llm_response.finish_reason = finish_reason
-    else:
-      finish_reason_str = str(finish_reason).lower()
-      llm_response.finish_reason = _FINISH_REASON_MAPPING.get(
-          finish_reason_str, types.FinishReason.OTHER
+  mapped_finish_reason = _map_finish_reason(finish_reason)
+  if mapped_finish_reason:
+    llm_response.finish_reason = mapped_finish_reason
+    if mapped_finish_reason != types.FinishReason.STOP:
+      llm_response.error_code = mapped_finish_reason
+      llm_response.error_message = _finish_reason_to_error_message(
+          mapped_finish_reason
       )
   if response.get("usage", None):
     usage_dict = response["usage"]
@@ -1888,7 +1893,7 @@ def _finish_reason_to_error_message(
   """Returns an error message for non-stop finish reasons."""
   if finish_reason == types.FinishReason.MAX_TOKENS:
     return "Maximum tokens reached"
-  return f"Finished with {finish_reason}"
+  return f"Finished with {finish_reason.name}"
 
 
 def _enforce_strict_openai_schema(schema: dict[str, Any]) -> None:

tests/unittests/models/test_litellm.py

@@ -4691,6 +4691,107 @@ async def test_finish_reason_propagation(
   mock_acompletion.assert_called_once()
 
 
+def test_model_response_to_generate_content_response_no_message_with_finish_reason():
+  """Test response with no message but finish_reason returns empty LlmResponse.
+
+  This test covers issue #3618: when a turn ends with tool calls and no final
+  message, we should return an empty LlmResponse instead of raising ValueError.
+  """
+  response = ModelResponse(
+      model="test_model",
+      choices=[{
+          "finish_reason": "tool_calls",
+          # message is missing/None
+      }],
+      usage={
+          "prompt_tokens": 10,
+          "completion_tokens": 5,
+          "total_tokens": 15,
+      },
+  )
+  # Force message to be None to guarantee hitting the else branch
+  response.choices[0].message = None
+
+  llm_response = _model_response_to_generate_content_response(response)
+
+  # Should return empty LlmResponse, not raise ValueError
+  assert llm_response.content is not None
+  assert llm_response.content.role == "model"
+  assert len(llm_response.content.parts) == 0
+  # tool_calls maps to STOP
+  assert llm_response.finish_reason == types.FinishReason.STOP
+  assert llm_response.usage_metadata is not None
+  assert llm_response.usage_metadata.prompt_token_count == 10
+  assert llm_response.usage_metadata.candidates_token_count == 5
+  assert llm_response.model_version == "test_model"
+
+
+def test_model_response_to_generate_content_response_no_message_no_finish_reason():
+  """Test response with no message and no finish_reason returns empty LlmResponse."""
+  response = ModelResponse(
+      model="test_model",
+      choices=[{
+          # Both message and finish_reason are missing
+      }],
+  )
+  # Force message to be None to guarantee hitting the else branch
+  response.choices[0].message = None
+
+  llm_response = _model_response_to_generate_content_response(response)
+
+  # Should return empty LlmResponse, not raise ValueError
+  assert llm_response.content is not None
+  assert llm_response.content.role == "model"
+  assert len(llm_response.content.parts) == 0
+  # finish_reason may be None or have a default value - the important thing
+  # is that we don't raise ValueError
+  assert llm_response.model_version == "test_model"
+
+
+def test_model_response_to_generate_content_response_empty_message_dict():
+  """Test response with empty message dict returns empty LlmResponse."""
+  response = ModelResponse(
+      model="test_model",
+      choices=[{
+          "message": {},  # Empty dict is falsy
+          "finish_reason": "stop",
+      }],
+      usage={
+          "prompt_tokens": 5,
+          "completion_tokens": 3,
+          "total_tokens": 8,
+      },
+  )
+  # Ensure we test the parsing of an empty message dictionary rather than None.
+
+  llm_response = _model_response_to_generate_content_response(response)
+
+  # Should return empty LlmResponse, not raise ValueError
+  assert llm_response.content is not None
+  assert llm_response.content.role == "model"
+  assert len(llm_response.content.parts) == 0
+  assert llm_response.finish_reason == types.FinishReason.STOP
+  assert llm_response.usage_metadata is not None
+
+
+def test_model_response_to_generate_content_response_safety_finish_reason():
+  """Test that SAFETY finish reason sets error_code and error_message."""
+  response = ModelResponse(
+      model="test_model",
+      choices=[{
+          "finish_reason": "content_filter",
+      }],
+  )
+  # Force message to be None to guarantee hitting the else branch
+  response.choices[0].message = None
+
+  llm_response = _model_response_to_generate_content_response(response)
+
+  assert llm_response.finish_reason == types.FinishReason.SAFETY
+  assert llm_response.error_code == types.FinishReason.SAFETY
+  assert llm_response.error_message == "Finished with SAFETY"
+
+
 @pytest.mark.skip(reason="LiteLLM finish_reason mapping behaviour changed")
 @pytest.mark.asyncio
 async def test_finish_reason_unknown_maps_to_other(