fix: resolve tool confirmation resumption failure in production

Ensure requested tool confirmations are correctly serialized and
deserialized in the session service.

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

Author: DeanChensj

pyproject.toml

@@ -31,6 +31,7 @@ classifiers = [
 ]
 dynamic = [ "version" ]
 dependencies = [
+  "aiohttp!=3.14.2",
   "aiosqlite>=0.21",
   "authlib>=1.6.6,<2",
   "click>=8.1.8,<9",

tests/unittests/flows/llm_flows/test_request_confirmation.py

@@ -17,9 +17,11 @@
 
 from google.adk.agents.llm_agent import LlmAgent
 from google.adk.events.event import Event
+from google.adk.events.event_actions import EventActions
 from google.adk.flows.llm_flows import functions
 from google.adk.flows.llm_flows.request_confirmation import request_processor
 from google.adk.models.llm_request import LlmRequest
+from google.adk.tools.function_tool import FunctionTool
 from google.adk.tools.tool_confirmation import ToolConfirmation
 from google.genai import types
 import pytest
@@ -407,3 +409,141 @@ async def test_request_confirmation_processor_finds_user_confirmation_in_default
 
     assert len(events) == 1
     assert events[0] == expected_event
+
+
+@pytest.mark.asyncio
+async def test_request_confirmation_processor_dynamic_success():
+  """Test successful processing of dynamic tool confirmation (require_confirmation=False)."""
+  agent = LlmAgent(
+      name="test_agent",
+      tools=[FunctionTool(mock_tool, require_confirmation=False)],
+  )
+  invocation_context = await testing_utils.create_invocation_context(
+      agent=agent
+  )
+  llm_request = LlmRequest()
+
+  original_function_call = types.FunctionCall(
+      name=MOCK_TOOL_NAME, args={"param1": "test"}, id=MOCK_FUNCTION_CALL_ID
+  )
+
+  # 1. Event with the original tool call
+  invocation_context.session.events.append(
+      Event(
+          author="agent",
+          content=types.Content(
+              parts=[types.Part(function_call=original_function_call)]
+          ),
+      )
+  )
+
+  # 2. Event with the tool's response requesting confirmation dynamically.
+  # This event needs to have actions.requested_tool_confirmations.
+  tool_confirmation_request = ToolConfirmation(
+      confirmed=False, hint="dynamic hint"
+  )
+  original_response_event = Event(
+      author="user",
+      content=types.Content(
+          parts=[
+              types.Part(
+                  function_response=types.FunctionResponse(
+                      name=MOCK_TOOL_NAME,
+                      id=MOCK_FUNCTION_CALL_ID,
+                      response={"status": "waiting_for_confirm"},
+                  )
+              )
+          ]
+      ),
+      actions=EventActions(
+          requested_tool_confirmations={
+              MOCK_FUNCTION_CALL_ID: tool_confirmation_request
+          }
+      ),
+  )
+  invocation_context.session.events.append(original_response_event)
+
+  # 3. Confirmation request event from the agent to the client.
+  tool_confirmation_args = {
+      "originalFunctionCall": original_function_call.model_dump(
+          exclude_none=True, by_alias=True
+      ),
+      "toolConfirmation": tool_confirmation_request.model_dump(
+          by_alias=True, exclude_none=True
+      ),
+  }
+  invocation_context.session.events.append(
+      Event(
+          author="agent",
+          content=types.Content(
+              parts=[
+                  types.Part(
+                      function_call=types.FunctionCall(
+                          name=functions.REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+                          args=tool_confirmation_args,
+                          id=MOCK_CONFIRMATION_FUNCTION_CALL_ID,
+                      )
+                  )
+              ]
+          ),
+      )
+  )
+
+  # 4. Event with the user's confirmation response.
+  user_confirmation = ToolConfirmation(confirmed=True)
+  invocation_context.session.events.append(
+      Event(
+          author="user",
+          content=types.Content(
+              parts=[
+                  types.Part(
+                      function_response=types.FunctionResponse(
+                          name=functions.REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+                          id=MOCK_CONFIRMATION_FUNCTION_CALL_ID,
+                          response={
+                              "response": user_confirmation.model_dump_json()
+                          },
+                      )
+                  )
+              ]
+          ),
+      )
+  )
+
+  expected_event = Event(
+      author="agent",
+      content=types.Content(
+          parts=[
+              types.Part(
+                  function_response=types.FunctionResponse(
+                      name=MOCK_TOOL_NAME,
+                      id=MOCK_FUNCTION_CALL_ID,
+                      response={"result": "Mock tool result with test"},
+                  )
+              )
+          ]
+      ),
+  )
+
+  with patch(
+      "google.adk.flows.llm_flows.functions.handle_function_call_list_async"
+  ) as mock_handle_function_call_list_async:
+    mock_handle_function_call_list_async.return_value = expected_event
+
+    events = []
+    async for event in request_processor.run_async(
+        invocation_context, llm_request
+    ):
+      events.append(event)
+
+    assert len(events) == 1
+    assert events[0] == expected_event
+
+    mock_handle_function_call_list_async.assert_called_once()
+    args, _ = mock_handle_function_call_list_async.call_args
+
+    assert list(args[1]) == [original_function_call]  # function_calls
+    assert args[3] == {MOCK_FUNCTION_CALL_ID}  # tools_to_confirm
+    assert (
+        args[4][MOCK_FUNCTION_CALL_ID] == user_confirmation
+    )  # tool_confirmation_dict

tests/unittests/sessions/test_session_service.py

@@ -32,6 +32,7 @@
 from google.adk.sessions.in_memory_session_service import InMemorySessionService
 from google.adk.sessions.sqlite_session_service import SqliteSessionService
 from google.adk.sessions.vertex_ai_session_service import VertexAiSessionService
+from google.adk.tools.tool_confirmation import ToolConfirmation
 from google.genai import types
 import pytest
 from sqlalchemy import delete
@@ -726,6 +727,51 @@ async def test_append_event_complete(session_service):
   )
 
 
+# pylint: disable=redefined-outer-name
+@pytest.mark.asyncio
+async def test_append_event_with_requested_tool_confirmations(session_service):
+  """Tests that EventActions.requested_tool_confirmations is preserved in session service."""
+  app_name = 'my_app'
+  user_id = 'user'
+
+  session = await session_service.create_session(
+      app_name=app_name, user_id=user_id
+  )
+  event = Event(
+      invocation_id='invocation',
+      author='user',
+      actions=EventActions(
+          requested_tool_confirmations={
+              'tool_call_1': ToolConfirmation(
+                  hint='dynamic hint',
+                  confirmed=False,
+                  payload={
+                      'collection_name': 'photos',
+                      'resource_id': 'album_1',
+                  },
+              )
+          }
+      ),
+  )
+  await session_service.append_event(session=session, event=event)
+
+  refreshed_session = await session_service.get_session(
+      app_name=app_name, user_id=user_id, session_id=session.id
+  )
+  assert refreshed_session is not None
+  assert len(refreshed_session.events) == 1
+  retrieved_event = refreshed_session.events[0]
+  assert retrieved_event.actions is not None
+  assert 'tool_call_1' in retrieved_event.actions.requested_tool_confirmations
+  tc = retrieved_event.actions.requested_tool_confirmations['tool_call_1']
+  assert tc.hint == 'dynamic hint'
+  assert tc.payload == {
+      'collection_name': 'photos',
+      'resource_id': 'album_1',
+  }
+  assert not tc.confirmed
+
+
 @pytest.mark.asyncio
 async def test_session_last_update_time_updates_on_event(session_service):
   app_name = 'my_app'