Merge branch 'main' into feat/bigtable-parameterized-views

Author: rohityan

CONTRIBUTING.md

@@ -133,7 +133,7 @@ part before or alongside your code PR.
 1. **Clone the repository:**
 
    ```shell
-   gh repo clone google/adk-python -- -b v2
+   gh repo clone google/adk-python
    cd adk-python
    ```
 

src/google/adk/errors/malformed_function_call_error.py

@@ -108,7 +108,6 @@ def _rearrange_events_for_async_function_responses_in_history(
     events: list[Event],
 ) -> list[Event]:
   """Rearrange the async function_response events in the history."""
-
   function_call_id_to_response_events_index: dict[str, int] = {}
   for i, event in enumerate(events):
     function_responses = event.get_function_responses()
@@ -117,6 +116,9 @@ def _rearrange_events_for_async_function_responses_in_history(
         function_call_id = function_response.id
         function_call_id_to_response_events_index[function_call_id] = i
 
+  if not function_call_id_to_response_events_index:
+    return events
+
   result_events: list[Event] = []
   for event in events:
     if event.get_function_responses():

src/google/adk/flows/llm_flows/contents.py

@@ -553,11 +553,14 @@ async def generate_content_async(
         else NOT_GIVEN
     )
     thinking = _build_anthropic_thinking_param(llm_request.config)
+    system = NOT_GIVEN
+    if llm_request.config.system_instruction is not None:
+      system = llm_request.config.system_instruction
 
     if not stream:
       message = await self._anthropic_client.messages.create(
           model=model_to_use,
-          system=llm_request.config.system_instruction,
+          system=system,
           messages=messages,
           tools=tools,
           tool_choice=tool_choice,
@@ -567,14 +570,15 @@ async def generate_content_async(
       yield message_to_generate_content_response(message)
     else:
       async for response in self._generate_content_streaming(
-          llm_request, messages, tools, tool_choice, thinking
+          llm_request, messages, system, tools, tool_choice, thinking
       ):
         yield response
 
   async def _generate_content_streaming(
       self,
       llm_request: LlmRequest,
       messages: list[anthropic_types.MessageParam],
+      system: Union[str, types.Content, NotGiven],
       tools: Union[Iterable[anthropic_types.ToolUnionParam], NotGiven],
       tool_choice: Union[anthropic_types.ToolChoiceParam, NotGiven],
       thinking: Union[
@@ -591,7 +595,7 @@ async def _generate_content_streaming(
     model_to_use = self._resolve_model_name(llm_request.model)
     raw_stream = await self._anthropic_client.messages.create(
         model=model_to_use,
-        system=llm_request.config.system_instruction,
+        system=system,
         messages=messages,
         tools=tools,
         tool_choice=tool_choice,

src/google/adk/models/anthropic_llm.py

@@ -33,7 +33,6 @@
 from google.genai.errors import ClientError
 from typing_extensions import override
 
-from ..errors.malformed_function_call_error import MalformedFunctionCallError
 from ..utils._google_client_headers import get_tracking_headers
 from ..utils._google_client_headers import merge_tracking_headers
 from ..utils.context_utils import Aclosing
@@ -63,27 +62,6 @@
 """
 
 
-def _raise_for_malformed_function_call(llm_response: LlmResponse) -> None:
-  """Raises when the model returned a malformed function call with no content.
-
-  A ``MALFORMED_FUNCTION_CALL`` finish reason yields a response that carries an
-  error code but nothing the agent can act on. Left alone it builds a
-  content-free event with no function call, which silently ends the invocation.
-  Raising routes it through the on_model_error callbacks so they can recover,
-  mirroring the LiteLlm malformed-arguments path. The error subclasses
-  ``ValueError`` so callbacks can match this case specifically without breaking
-  existing handlers.
-  """
-  if (
-      llm_response.finish_reason == types.FinishReason.MALFORMED_FUNCTION_CALL
-      and not (llm_response.content and llm_response.content.parts)
-  ):
-    raise MalformedFunctionCallError(
-        llm_response.error_message
-        or 'Model returned a malformed function call.'
-    )
-
-
 class _ResourceExhaustedError(ClientError):
   """Represents a resources exhausted error received from the Model."""
 
@@ -280,7 +258,6 @@ async def generate_content_async(
                 aggregator.process_response(response)
             ) as aggregator_gen:
               async for llm_response in aggregator_gen:
-                _raise_for_malformed_function_call(llm_response)
                 yield llm_response
         if (close_result := aggregator.close()) is not None:
           # Populate cache metadata in the final aggregated response for
@@ -289,7 +266,6 @@ async def generate_content_async(
             cache_manager.populate_cache_metadata_in_response(
                 close_result, cache_metadata
             )
-          _raise_for_malformed_function_call(close_result)
           yield close_result
 
       else:
@@ -307,7 +283,6 @@ async def generate_content_async(
           cache_manager.populate_cache_metadata_in_response(
               llm_response, cache_metadata
           )
-        _raise_for_malformed_function_call(llm_response)
         yield llm_response
     except ClientError as ce:
       if ce.code == 429:

src/google/adk/models/google_llm.py

@@ -1306,3 +1306,37 @@ def test_get_contents_live_history_rebuild():
 
   assert result[1].role == "user"
   assert "returned result" in result[1].parts[1].text
+
+
+def test_rearrange_async_function_responses_early_returns_when_no_responses():
+  """Rearrangement is a no-op when no event carries function_responses."""
+  events = [
+      Event(
+          invocation_id="inv1",
+          author="user",
+          content=types.UserContent("hi"),
+      ),
+      Event(
+          invocation_id="inv2",
+          author="test_agent",
+          content=types.ModelContent("hello"),
+      ),
+      Event(
+          invocation_id="inv3",
+          author="test_agent",
+          content=types.Content(
+              role="model",
+              parts=[
+                  types.Part(
+                      function_call=types.FunctionCall(
+                          id="adk-1", name="tool", args={}
+                      )
+                  )
+              ],
+          ),
+      ),
+  ]
+  result = contents._rearrange_events_for_async_function_responses_in_history(  # pylint: disable=protected-access
+      events
+  )
+  assert result is events

tests/unittests/flows/llm_flows/test_contents.py

@@ -21,6 +21,7 @@
 from unittest.mock import AsyncMock
 from unittest.mock import MagicMock
 
+from anthropic import NOT_GIVEN
 from anthropic import types as anthropic_types
 from google.adk import version as adk_version
 from google.adk.models import anthropic_llm
@@ -2134,3 +2135,93 @@ async def test_generate_content_async_pairs_invalid_tool_ids(
   ]
   assert len(set(use_ids)) == expected_unique
   assert set(use_ids) == set(result_ids)
+
+
+@pytest.mark.asyncio
+async def test_non_streaming_no_system_instruction_passes_not_given():
+  """system=NOT_GIVEN when LlmRequest has no system_instruction."""
+  llm = AnthropicLlm(model="claude-sonnet-4-20250514")
+
+  mock_message = anthropic_types.Message(
+      id="msg_test",
+      content=[
+          anthropic_types.TextBlock(text="ok", type="text", citations=None)
+      ],
+      model="claude-sonnet-4-20250514",
+      role="assistant",
+      stop_reason="end_turn",
+      stop_sequence=None,
+      type="message",
+      usage=anthropic_types.Usage(
+          input_tokens=1,
+          output_tokens=1,
+          cache_creation_input_tokens=0,
+          cache_read_input_tokens=0,
+          server_tool_use=None,
+          service_tier=None,
+      ),
+  )
+
+  mock_client = MagicMock()
+  mock_client.messages.create = AsyncMock(return_value=mock_message)
+
+  request = LlmRequest(
+      model="claude-sonnet-4-20250514",
+      contents=[Content(role="user", parts=[Part.from_text(text="Hi")])],
+  )
+  assert request.config.system_instruction is None
+
+  with mock.patch.object(llm, "_anthropic_client", mock_client):
+    _ = [r async for r in llm.generate_content_async(request, stream=False)]
+
+  mock_client.messages.create.assert_called_once()
+  _, kwargs = mock_client.messages.create.call_args
+  assert kwargs["system"] is NOT_GIVEN
+
+
+@pytest.mark.asyncio
+async def test_streaming_no_system_instruction_passes_not_given():
+  """system=NOT_GIVEN on the streaming path when no system_instruction."""
+  llm = AnthropicLlm(model="claude-sonnet-4-20250514")
+
+  events = [
+      MagicMock(
+          type="message_start",
+          message=MagicMock(usage=MagicMock(input_tokens=1, output_tokens=0)),
+      ),
+      MagicMock(
+          type="content_block_start",
+          index=0,
+          content_block=anthropic_types.TextBlock(text="", type="text"),
+      ),
+      MagicMock(
+          type="content_block_delta",
+          index=0,
+          delta=anthropic_types.TextDelta(text="ok", type="text_delta"),
+      ),
+      MagicMock(type="content_block_stop", index=0),
+      MagicMock(
+          type="message_delta",
+          delta=MagicMock(stop_reason="end_turn"),
+          usage=MagicMock(output_tokens=1),
+      ),
+      MagicMock(type="message_stop"),
+  ]
+
+  mock_client = MagicMock()
+  mock_client.messages.create = AsyncMock(
+      return_value=_make_mock_stream_events(events)
+  )
+
+  request = LlmRequest(
+      model="claude-sonnet-4-20250514",
+      contents=[Content(role="user", parts=[Part.from_text(text="Hi")])],
+  )
+  assert request.config.system_instruction is None
+
+  with mock.patch.object(llm, "_anthropic_client", mock_client):
+    _ = [r async for r in llm.generate_content_async(request, stream=True)]
+
+  mock_client.messages.create.assert_called_once()
+  _, kwargs = mock_client.messages.create.call_args
+  assert kwargs["system"] is NOT_GIVEN

tests/unittests/models/test_anthropic_llm.py

@@ -21,7 +21,6 @@
 
 from google.adk import version as adk_version
 from google.adk.agents.context_cache_config import ContextCacheConfig
-from google.adk.errors.malformed_function_call_error import MalformedFunctionCallError
 from google.adk.models.cache_metadata import CacheMetadata
 from google.adk.models.gemini_llm_connection import GeminiLlmConnection
 from google.adk.models.google_llm import _build_function_declaration_log
@@ -323,70 +322,6 @@ async def mock_coro():
     mock_client.aio.models.generate_content.assert_called_once()
 
 
-@pytest.mark.asyncio
-async def test_generate_content_async_malformed_function_call_raises(
-    gemini_llm, llm_request
-):
-  malformed_response = types.GenerateContentResponse(
-      candidates=[
-          types.Candidate(
-              content=None,
-              finish_reason=types.FinishReason.MALFORMED_FUNCTION_CALL,
-              finish_message="Malformed function call: print(default_api.f(x=",
-          )
-      ]
-  )
-  with mock.patch.object(gemini_llm, "api_client") as mock_client:
-
-    async def mock_coro():
-      return malformed_response
-
-    mock_client.aio.models.generate_content.return_value = mock_coro()
-
-    with pytest.raises(
-        MalformedFunctionCallError, match="alformed function call"
-    ):
-      _ = [
-          resp
-          async for resp in gemini_llm.generate_content_async(
-              llm_request, stream=False
-          )
-      ]
-
-
-@pytest.mark.asyncio
-async def test_generate_content_async_stream_malformed_function_call_raises(
-    gemini_llm, llm_request
-):
-  mock_responses = [
-      types.GenerateContentResponse(
-          candidates=[
-              types.Candidate(
-                  content=None,
-                  finish_reason=types.FinishReason.MALFORMED_FUNCTION_CALL,
-                  finish_message="Malformed function call",
-              )
-          ]
-      ),
-  ]
-  with mock.patch.object(gemini_llm, "api_client") as mock_client:
-
-    async def mock_coro():
-      return MockAsyncIterator(mock_responses)
-
-    mock_client.aio.models.generate_content_stream.return_value = mock_coro()
-
-    with pytest.raises(
-        MalformedFunctionCallError, match="alformed function call"
-    ):
-      _ = [
-          resp
-          async for resp in gemini_llm.generate_content_async(
-              llm_request, stream=True
-          )
-      ]
-
-
 @pytest.mark.asyncio
 async def test_generate_content_async_stream(gemini_llm, llm_request):
   with mock.patch.object(gemini_llm, "api_client") as mock_client: