perf: avoid deepcopy of session contents when building LLM requests

`_get_contents` deep-copied `event.content` for every event on every LLM
request, just to strip ADK-generated (`adk-` prefixed) function call/response
ids and to isolate the contents from downstream request processors that mutate
parts in place (e.g. nl_planning clearing `part.thought`, code_execution
rewriting parts). The deepcopy recursed into large
`function_call.args`/`inline_data` payloads, and cost grew with conversation
length (a dominant non-LLM CPU sink in profiling, ~4-7s of a ~30s run).

Replace it with a shallow copy: the `Content` and every `Part` are
`model_copy`-d (so downstream in-place mutations stay isolated from session
events), but the payloads (`args`/`response`/`inline_data`/...) are shared by
reference instead of deep-copied.

Adds regression tests (id stripping and downstream-mutation isolation) and a
google_benchmark perf script.

Benchmark (_get_contents over a 500-turn history, ~23x):

Before (copy.deepcopy):
  -------------------------------------------------------
  Benchmark             Time             CPU   Iterations
  -------------------------------------------------------
  get_contents  781559706 ns    781443557 ns            1

After (per-part shallow copy):
  -------------------------------------------------------
  Benchmark             Time             CPU   Iterations
  -------------------------------------------------------
  get_contents   33996069 ns     33987197 ns           20

PiperOrigin-RevId: 940664677

Author: google-genai-bot

pyproject.toml

@@ -95,6 +95,9 @@ optional-dependencies.antigravity = [
   "google-antigravity>=0.1,<0.2",
   "protobuf>=6",
 ]
+optional-dependencies.benchmark = [
+  "google-benchmark>=1.9",
+]
 optional-dependencies.community = [
   "google-adk-community",
 ]

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

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-import copy
 import logging
 from typing import AsyncGenerator
 from typing import Optional
@@ -27,7 +26,7 @@
 from ...events.event import Event
 from ...models.llm_request import LlmRequest
 from ._base_llm_processor import BaseLlmRequestProcessor
-from .functions import remove_client_function_call_id
+from .functions import AF_FUNCTION_CALL_ID_PREFIX
 from .functions import REQUEST_CONFIRMATION_FUNCTION_CALL_NAME
 from .functions import REQUEST_EUC_FUNCTION_CALL_NAME
 
@@ -512,6 +511,52 @@ def _is_timestamp_compacted(ts: float) -> bool:
   return [event for _, _, event in processed_items]
 
 
+def _copy_content_for_request(
+    content: types.Content,
+    *,
+    strip_client_function_call_ids: bool,
+) -> types.Content:
+  """Returns a session-isolated copy of ``content`` for an LLM request.
+
+  ``Content`` and every ``Part`` are shallow-copied so downstream request
+  processors (nl_planning, code_execution) can mutate them without corrupting
+  session events; payloads are shared by reference to avoid the deep recursion
+  that the previous ``deepcopy`` paid on every request.
+
+  Because the copy is shallow, nested fields (e.g. ``function_call.args``,
+  ``inline_data.data``) are shared with the session events. Downstream
+  processors must therefore only replace ``Part`` objects or set top-level
+  ``Part`` fields; mutating a nested field in place would corrupt session
+  history.
+
+  Args:
+    content: The (session-owned) content to copy. Not mutated.
+    strip_client_function_call_ids: Whether to remove ``adk-`` prefixed function
+      call/response ids (mirrors ``remove_client_function_call_id``).
+
+  Returns:
+    An isolated ``Content`` safe to attach to an ``LlmRequest``.
+  """
+  new_content = content.model_copy()
+  parts = content.parts
+  if not parts:
+    return new_content
+
+  new_parts = []
+  for part in parts:
+    new_part = part.model_copy()
+    if strip_client_function_call_ids:
+      fc = new_part.function_call
+      if fc and fc.id and fc.id.startswith(AF_FUNCTION_CALL_ID_PREFIX):
+        new_part.function_call = fc.model_copy(update={'id': None})
+      fr = new_part.function_response
+      if fr and fr.id and fr.id.startswith(AF_FUNCTION_CALL_ID_PREFIX):
+        new_part.function_response = fr.model_copy(update={'id': None})
+    new_parts.append(new_part)
+  new_content.parts = new_parts
+  return new_content
+
+
 def _get_contents(
     current_branch: Optional[str],
     events: list[Event],
@@ -659,11 +704,13 @@ def _get_contents(
   # Convert events to contents
   contents = []
   for event in result_events:
-    content = copy.deepcopy(event.content)
-    if content:
-      if not preserve_function_call_ids:
-        remove_client_function_call_id(content)
-      contents.append(content)
+    if event.content:
+      contents.append(
+          _copy_content_for_request(
+              event.content,
+              strip_client_function_call_ids=not preserve_function_call_ids,
+          )
+      )
 
   # for scoped agents (task / single_turn), prepend a
   # synthetic user-role content built from the originating FC's args.

tests/benchmarks/benchmark_contents.py

@@ -0,0 +1,87 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Microbenchmark for building LLM request contents from session history.
+
+Times contents._get_contents over a large history with sizeable function-call
+payloads. To run the benchmark:
+
+  uv run python tests/benchmarks/benchmark_contents.py
+"""
+
+from google.adk.events.event import Event
+from google.adk.flows.llm_flows import contents
+from google.genai import types
+import google_benchmark
+
+_NUM_EVENTS = 500
+_PAYLOAD_SIZE = 200
+
+
+def _make_events(num_events: int, payload_size: int) -> list[Event]:
+  """Builds a session history with sizeable function-call payloads."""
+  payload = {f"k{i}": list(range(payload_size)) for i in range(10)}
+  events = [
+      Event(
+          invocation_id="inv0",
+          author="user",
+          content=types.UserContent("start"),
+      )
+  ]
+  for i in range(num_events):
+    call_id = f"adk-call-{i}"
+    events.append(
+        Event(
+            invocation_id=f"inv{i}",
+            author="agent",
+            content=types.Content(
+                role="model",
+                parts=[
+                    types.Part(
+                        function_call=types.FunctionCall(
+                            id=call_id, name="tool", args=dict(payload)
+                        )
+                    )
+                ],
+            ),
+        )
+    )
+    events.append(
+        Event(
+            invocation_id=f"inv{i}",
+            author="agent",
+            content=types.Content(
+                role="user",
+                parts=[
+                    types.Part(
+                        function_response=types.FunctionResponse(
+                            id=call_id, name="tool", response=dict(payload)
+                        )
+                    )
+                ],
+            ),
+        )
+    )
+  return events
+
+
+@google_benchmark.register
+def get_contents(state):
+  events = _make_events(_NUM_EVENTS, _PAYLOAD_SIZE)
+  while state:
+    contents._get_contents(None, events, "agent")
+
+
+if __name__ == "__main__":
+  google_benchmark.main()

tests/unittests/flows/llm_flows/test_contents.py

@@ -15,6 +15,7 @@
 from google.adk.agents.llm_agent import Agent
 from google.adk.events.event import Event
 from google.adk.events.event_actions import EventActions
+from google.adk.flows.llm_flows import _nl_planning
 from google.adk.flows.llm_flows import contents
 from google.adk.flows.llm_flows.contents import request_processor
 from google.adk.flows.llm_flows.functions import REQUEST_CONFIRMATION_FUNCTION_CALL_NAME
@@ -1001,6 +1002,122 @@ async def test_adk_function_call_ids_are_stripped_for_non_interactions_model():
   assert user_fr_part.function_response.id is None
 
 
+@pytest.mark.asyncio
+async def test_stripping_function_call_ids_does_not_mutate_session_events():
+  """Stripping ``adk-`` ids must not mutate the session-owned events."""
+  agent = Agent(model="gemini-2.5-flash", name="test_agent")
+  llm_request = LlmRequest(model="gemini-2.5-flash")
+  invocation_context = await testing_utils.create_invocation_context(
+      agent=agent
+  )
+
+  # Shared id so the history rearrange logic can pair call and response.
+  function_call_id = "adk-test-call-id"
+  fc_part = types.Part(
+      function_call=types.FunctionCall(
+          id=function_call_id,
+          name="test_tool",
+          args={"x": 1},
+      )
+  )
+  fr_part = types.Part(
+      function_response=types.FunctionResponse(
+          id=function_call_id,
+          name="test_tool",
+          response={"result": 2},
+      )
+  )
+  events = [
+      Event(
+          invocation_id="inv1",
+          author="user",
+          content=types.UserContent("Call the tool"),
+      ),
+      Event(
+          invocation_id="inv2",
+          author="test_agent",
+          content=types.Content(role="model", parts=[fc_part]),
+      ),
+      Event(
+          invocation_id="inv3",
+          author="test_agent",
+          content=types.Content(role="user", parts=[fr_part]),
+      ),
+  ]
+  invocation_context.session.events = events
+
+  async for _ in contents.request_processor.run_async(
+      invocation_context, llm_request
+  ):
+    pass
+
+  model_fc_part = llm_request.contents[1].parts[0]
+  assert model_fc_part.function_call.id is None
+  user_fr_part = llm_request.contents[2].parts[0]
+  assert user_fr_part.function_response.id is None
+
+  assert fc_part.function_call.id == function_call_id
+  assert fr_part.function_response.id == function_call_id
+  assert events[1].content.parts[0].function_call.id == function_call_id
+  assert events[2].content.parts[0].function_response.id == function_call_id
+  assert model_fc_part is not fc_part
+  assert user_fr_part is not fr_part
+
+
+@pytest.mark.asyncio
+async def test_downstream_part_mutation_does_not_corrupt_session_events():
+  """Request parts must survive in-place mutation by later processors."""
+  agent = Agent(model="gemini-2.5-flash", name="test_agent")
+  llm_request = LlmRequest(model="gemini-2.5-flash")
+  invocation_context = await testing_utils.create_invocation_context(
+      agent=agent
+  )
+
+  # A thought=True function-call part survives context filtering.
+  fc_part = types.Part(
+      function_call=types.FunctionCall(id="fc1", name="t", args={"x": 1}),
+  )
+  fc_part.thought = True
+  events = [
+      Event(
+          invocation_id="inv1",
+          author="user",
+          content=types.UserContent("Call the tool"),
+      ),
+      Event(
+          invocation_id="inv2",
+          author="test_agent",
+          content=types.Content(role="model", parts=[fc_part]),
+      ),
+      Event(
+          invocation_id="inv3",
+          author="test_agent",
+          content=types.Content(
+              role="user",
+              parts=[
+                  types.Part(
+                      function_response=types.FunctionResponse(
+                          id="fc1", name="t", response={"r": 2}
+                      )
+                  )
+              ],
+          ),
+      ),
+  ]
+  invocation_context.session.events = events
+
+  async for _ in contents.request_processor.run_async(
+      invocation_context, llm_request
+  ):
+    pass
+
+  # nl_planning clears thoughts in place on the request parts.
+  _nl_planning._remove_thought_from_request(llm_request)
+
+  assert fc_part.thought is True
+  assert events[1].content.parts[0].thought is True
+
+
 @pytest.mark.asyncio
 async def test_adk_function_call_ids_preserved_for_interactions_model():
   """Test ADK generated ids are preserved for interactions requests."""