From 70b01d50202b402d8cc2cd3e6a9564bba6ac1172 Mon Sep 17 00:00:00 2001 From: Mohit Sharma Date: Mon, 2 Nov 2026 14:01:40 +0530 Subject: [PATCH 1/5] fix(runner): raise ValueError in run_async when new_message and invocation_id are None (#7934) --- src/google/adk/runners.py | 7 +++++ tests/unittests/test_runners.py | 48 +++++++++++++++++++++++++++++++++ 2 files changed, 55 insertions(+) diff --git a/src/google/adk/runners.py b/src/google/adk/runners.py index 84a6b25e79d..4a67aad12e6 100644 --- a/src/google/adk/runners.py +++ b/src/google/adk/runners.py @@ -1177,6 +1177,13 @@ async def run_async( if new_message and new_message.role != 'user': new_message = types.Content(role='user', parts=new_message.parts) + if not invocation_id and new_message is None: + raise ValueError( + 'Running an agent requires either a new_message or an ' + 'invocation_id to resume a previous invocation. ' + f'Session: {session_id}, User: {user_id}' + ) + from .agents.llm_agent import LlmAgent from .workflow._base_node import BaseNode diff --git a/tests/unittests/test_runners.py b/tests/unittests/test_runners.py index 33693d1a856..fd6d39128e5 100644 --- a/tests/unittests/test_runners.py +++ b/tests/unittests/test_runners.py @@ -7441,5 +7441,53 @@ async def _consume(): assert not [e for e in session.events if e.actions.compaction] +async def test_run_async_llm_agent_without_message_or_invocation_id_raises_value_error(): + """Runner.run_async must raise ValueError when both new_message and invocation_id are None (#7934).""" + session_service = InMemorySessionService() + runner = Runner( + app_name="test_app", + agent=MockLlmAgent("test_agent"), + session_service=session_service, + auto_create_session=True, + ) + with pytest.raises( + ValueError, + match=r"Running an agent requires either a new_message or an invocation_id", + ): + agen = runner.run_async( + user_id="u", + session_id="s", + new_message=None, + invocation_id=None, + ) + async for _ in agen: + pass + + +async def test_run_async_base_node_without_message_or_invocation_id_raises_value_error(): + """Runner.run_async with BaseNode root must raise ValueError when both new_message and invocation_id are None (#7934).""" + from google.adk.workflow._base_node import BaseNode + + session_service = InMemorySessionService() + node = BaseNode(name="test_node") + runner = Runner( + app=App(name="test_app", root_agent=node), + session_service=session_service, + auto_create_session=True, + ) + with pytest.raises( + ValueError, + match=r"Running an agent requires either a new_message or an invocation_id", + ): + agen = runner.run_async( + user_id="u", + session_id="s", + new_message=None, + invocation_id=None, + ) + async for _ in agen: + pass + + if __name__ == "__main__": pytest.main([__file__]) From 9d31880db5cf8c0b1d0f61fea2048cd51f58a30b Mon Sep 17 00:00:00 2001 From: Mohit Sharma Date: Tue, 3 Nov 2026 17:50:28 +0530 Subject: [PATCH 2/5] fix(runner): permit run_async without new_message when session has history (#7934) --- src/google/adk/runners.py | 17 ++++++++++------- tests/unittests/test_runners.py | 34 +++++++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+), 7 deletions(-) diff --git a/src/google/adk/runners.py b/src/google/adk/runners.py index 4a67aad12e6..9cc828f97c9 100644 --- a/src/google/adk/runners.py +++ b/src/google/adk/runners.py @@ -1177,7 +1177,13 @@ async def run_async( if new_message and new_message.role != 'user': new_message = types.Content(role='user', parts=new_message.parts) - if not invocation_id and new_message is None: + session = await self._get_or_create_session( + user_id=user_id, + session_id=session_id, + get_session_config=run_config.get_session_config, + ) + + if not invocation_id and new_message is None and not session.events: raise ValueError( 'Running an agent requires either a new_message or an ' 'invocation_id to resume a previous invocation. ' @@ -1198,11 +1204,6 @@ async def run_async( # output field (an A2A server turns that into an artifact; a direct caller # reads it off the event stream). if effective_mode in (_AgentMode.CHAT, _AgentMode.TASK): - session = await self._get_or_create_session( - user_id=user_id, - session_id=session_id, - get_session_config=run_config.get_session_config, - ) agent_to_run: BaseAgent if self._uses_legacy_sub_agent_picker(): agent_to_run = self._find_agent_to_run( @@ -1250,6 +1251,8 @@ async def run_async( state_delta=state_delta, run_config=run_config, yield_user_message=yield_user_message, + node=self.agent, + session=session, abort_signal=abort_signal, ) ) as agen: @@ -1269,7 +1272,7 @@ async def _run_with_trace( get_session_config=run_config.get_session_config, ) - if not invocation_id and new_message is None: + if not invocation_id and new_message is None and not session.events: raise ValueError( 'Running an agent requires either a new_message or an ' 'invocation_id to resume a previous invocation. ' diff --git a/tests/unittests/test_runners.py b/tests/unittests/test_runners.py index fd6d39128e5..847d1c3ae9f 100644 --- a/tests/unittests/test_runners.py +++ b/tests/unittests/test_runners.py @@ -7489,5 +7489,39 @@ async def test_run_async_base_node_without_message_or_invocation_id_raises_value pass +async def test_run_async_with_existing_history_and_no_new_message_succeeds(): + """Runner.run_async must succeed with new_message=None when session has history (#7934).""" + session_service = InMemorySessionService() + session = await session_service.create_session( + app_name="test_app", user_id="u", session_id="s" + ) + user_event = Event( + timestamp=1.0, + invocation_id="inv1", + author="user", + content=types.Content( + role="user", parts=[types.Part(text="hello previous")] + ), + ) + await session_service.append_event(session=session, event=user_event) + + runner = Runner( + app_name="test_app", + agent=MockLlmAgent("test_agent"), + session_service=session_service, + ) + + events = [ + e + async for e in runner.run_async( + user_id="u", + session_id="s", + new_message=None, + invocation_id=None, + ) + ] + assert events + + if __name__ == "__main__": pytest.main([__file__]) From 1ea3061ad2e4878bf3b96ff8bb8ec183ee0906f9 Mon Sep 17 00:00:00 2001 From: Mohit Sharma Date: Fri, 6 Nov 2026 22:19:31 +0530 Subject: [PATCH 3/5] fix(runner): avoid duplicate session fetch in _run_with_trace and strengthen history tests (#7934) # Conflicts: # src/google/adk/runners.py --- src/google/adk/runners.py | 19 +++++------- tests/unittests/test_runners.py | 55 ++++++++++++++++++++++++++++++++- 2 files changed, 61 insertions(+), 13 deletions(-) diff --git a/src/google/adk/runners.py b/src/google/adk/runners.py index 9cc828f97c9..1282bf0e14a 100644 --- a/src/google/adk/runners.py +++ b/src/google/adk/runners.py @@ -1265,18 +1265,13 @@ async def run_async( async def _run_with_trace( new_message: types.Content | None = None, invocation_id: str | None = None, + session: Session | None = None, ) -> AsyncGenerator[Event, None]: - session = await self._get_or_create_session( - user_id=user_id, - session_id=session_id, - get_session_config=run_config.get_session_config, - ) - - if not invocation_id and new_message is None and not session.events: - raise ValueError( - 'Running an agent requires either a new_message or an ' - 'invocation_id to resume a previous invocation. ' - f'Session: {session_id}, User: {user_id}' + if session is None: + session = await self._get_or_create_session( + user_id=user_id, + session_id=session_id, + get_session_config=run_config.get_session_config, ) is_resumable = ( @@ -1390,7 +1385,7 @@ async def execute( async with aclosing( _instrumentation.stream_in_scope( invocation_otel_context, - _run_with_trace(new_message, invocation_id), + _run_with_trace(new_message, invocation_id, session=session), ) ) as agen: async for event in agen: diff --git a/tests/unittests/test_runners.py b/tests/unittests/test_runners.py index 847d1c3ae9f..409f42bff57 100644 --- a/tests/unittests/test_runners.py +++ b/tests/unittests/test_runners.py @@ -7505,9 +7505,11 @@ async def test_run_async_with_existing_history_and_no_new_message_succeeds(): ) await session_service.append_event(session=session, event=user_event) + mock_model = testing_utils.MockModel.create(responses=["ok"]) + agent = LlmAgent(name="test_agent", model=mock_model) runner = Runner( app_name="test_app", - agent=MockLlmAgent("test_agent"), + agent=agent, session_service=session_service, ) @@ -7521,6 +7523,57 @@ async def test_run_async_with_existing_history_and_no_new_message_succeeds(): ) ] assert events + assert len(mock_model.requests) == 1 + assert any( + any(part.text == "hello previous" for part in c.parts) + for c in mock_model.requests[0].contents + if c.role == "user" + ) + + +async def test_run_async_workflow_root_with_existing_history_and_no_new_message_succeeds(): + """Runner.run_async with Workflow root must succeed with new_message=None when session has history (#7934).""" + from google.adk.workflow import START, Workflow + + session_service = InMemorySessionService() + session = await session_service.create_session( + app_name="test_app", user_id="u", session_id="s" + ) + user_event = Event( + timestamp=1.0, + invocation_id="inv1", + author="user", + content=types.Content( + role="user", parts=[types.Part(text="hello previous")] + ), + ) + await session_service.append_event(session=session, event=user_event) + + mock_model = testing_utils.MockModel.create(responses=["workflow reply"]) + agent = LlmAgent(name="test_agent", model=mock_model) + workflow = Workflow(name="test_wf", edges=[(START, agent)]) + runner = Runner( + app_name="test_app", + agent=workflow, + session_service=session_service, + ) + + events = [ + e + async for e in runner.run_async( + user_id="u", + session_id="s", + new_message=None, + invocation_id=None, + ) + ] + assert events + assert len(mock_model.requests) == 1 + assert any( + any(part.text == "hello previous" for part in c.parts) + for c in mock_model.requests[0].contents + if c.role == "user" + ) if __name__ == "__main__": From d0ee589e2388d6a9f115fb30b960f0900d7fb159 Mon Sep 17 00:00:00 2001 From: Mohit Sharma Date: Mon, 9 Nov 2026 16:52:16 +0530 Subject: [PATCH 4/5] test(runner): add SequentialAgent root empty and history test cases (#7934) --- tests/unittests/test_runners.py | 80 +++++++++++++++++++++++++++++++++ 1 file changed, 80 insertions(+) diff --git a/tests/unittests/test_runners.py b/tests/unittests/test_runners.py index 409f42bff57..2889f76c457 100644 --- a/tests/unittests/test_runners.py +++ b/tests/unittests/test_runners.py @@ -7576,5 +7576,85 @@ async def test_run_async_workflow_root_with_existing_history_and_no_new_message_ ) +async def test_run_async_sequential_agent_root_empty_and_history_cases(): + """Runner.run_async with SequentialAgent (BaseAgent) root checks empty session and proceeds with history (#7934).""" + from google.adk.agents.sequential_agent import SequentialAgent + + session_service = InMemorySessionService() + + # 1. Empty session: without new_message or invocation_id, raises ValueError before execution + empty_session = await session_service.create_session( + app_name="test_app", user_id="u", session_id="s_empty" + ) + mock_model1 = testing_utils.MockModel.create(responses=["step1"]) + seq1 = SequentialAgent( + name="seq1", sub_agents=[LlmAgent(name="sub1", model=mock_model1)] + ) + runner1 = Runner( + app=App( + name="test_app", + root_agent=seq1, + resumability_config=ResumabilityConfig(is_resumable=True), + ), + session_service=session_service, + ) + + with pytest.raises( + ValueError, + match=r"Running an agent requires either a new_message or an invocation_id", + ): + async for _ in runner1.run_async( + user_id="u", + session_id=empty_session.id, + new_message=None, + invocation_id=None, + ): + pass + + # 2. History session: with prior user event and resumable app, proceeds without new_message + history_session = await session_service.create_session( + app_name="test_app", user_id="u", session_id="s_history" + ) + user_event = Event( + timestamp=1.0, + invocation_id="inv1", + author="user", + content=types.Content( + role="user", parts=[types.Part(text="hello previous")] + ), + ) + await session_service.append_event(session=history_session, event=user_event) + + mock_model2 = testing_utils.MockModel.create(responses=["step1 reply"]) + seq2 = SequentialAgent( + name="seq2", sub_agents=[LlmAgent(name="sub2", model=mock_model2)] + ) + runner2 = Runner( + app=App( + name="test_app", + root_agent=seq2, + resumability_config=ResumabilityConfig(is_resumable=True), + ), + session_service=session_service, + ) + + events = [ + e + async for e in runner2.run_async( + user_id="u", + session_id=history_session.id, + new_message=None, + invocation_id="inv1", + ) + ] + assert events + assert len(mock_model2.requests) == 1 + assert any( + any(part.text == "hello previous" for part in c.parts) + for c in mock_model2.requests[0].contents + if c.role == "user" + ) + + if __name__ == "__main__": pytest.main([__file__]) From bad28cf4ec15f4bd03b3d9157b1da35c94ed711f Mon Sep 17 00:00:00 2001 From: Mohit Sharma Date: Mon, 16 Nov 2026 23:56:23 +0530 Subject: [PATCH 5/5] fix(runner): validate root LlmAgent mode before session fetch (#7934) --- src/google/adk/runners.py | 51 +++++++++++++++++---------------- tests/unittests/test_runners.py | 10 +++---- 2 files changed, 31 insertions(+), 30 deletions(-) diff --git a/src/google/adk/runners.py b/src/google/adk/runners.py index 1282bf0e14a..4b118e2fc07 100644 --- a/src/google/adk/runners.py +++ b/src/google/adk/runners.py @@ -1177,19 +1177,6 @@ async def run_async( if new_message and new_message.role != 'user': new_message = types.Content(role='user', parts=new_message.parts) - session = await self._get_or_create_session( - user_id=user_id, - session_id=session_id, - get_session_config=run_config.get_session_config, - ) - - if not invocation_id and new_message is None and not session.events: - raise ValueError( - 'Running an agent requires either a new_message or an ' - 'invocation_id to resume a previous invocation. ' - f'Session: {session_id}, User: {user_id}' - ) - from .agents.llm_agent import LlmAgent from .workflow._base_node import BaseNode @@ -1203,22 +1190,36 @@ async def run_async( # finish_task tool and its result is promoted onto the terminal event's # output field (an A2A server turns that into an artifact; a direct caller # reads it off the event stream). - if effective_mode in (_AgentMode.CHAT, _AgentMode.TASK): - agent_to_run: BaseAgent - if self._uses_legacy_sub_agent_picker(): - agent_to_run = self._find_agent_to_run( - _session_for_routing(session, new_message), self.agent - ) - else: - agent_to_run = self.agent - - # The agent_to_run will be built/cloned inside Context.run_node, - # so we don't call build_node here to avoid double cloning. - else: + if effective_mode not in (_AgentMode.CHAT, _AgentMode.TASK): raise ValueError( "LlmAgent as root agent must have mode='chat' or 'task', but got" f" mode='{effective_mode}'." ) + + session = await self._get_or_create_session( + user_id=user_id, + session_id=session_id, + get_session_config=run_config.get_session_config, + ) + + if not invocation_id and new_message is None and not session.events: + raise ValueError( + 'Running an agent requires either a new_message or an ' + 'invocation_id to resume a previous invocation. ' + f'Session: {session_id}, User: {user_id}' + ) + + if isinstance(self.agent, LlmAgent): + agent_to_run: BaseAgent + if self._uses_legacy_sub_agent_picker(): + agent_to_run = self._find_agent_to_run( + _session_for_routing(session, new_message), self.agent + ) + else: + agent_to_run = self.agent + + # The agent_to_run will be built/cloned inside Context.run_node, + # so we don't call build_node here to avoid double cloning. async with aclosing( self._run_node_async( user_id=user_id, diff --git a/tests/unittests/test_runners.py b/tests/unittests/test_runners.py index 2889f76c457..9c7ea57e8d1 100644 --- a/tests/unittests/test_runners.py +++ b/tests/unittests/test_runners.py @@ -59,7 +59,6 @@ from google.adk.sessions.base_session_service import GetSessionConfig from google.adk.sessions.in_memory_session_service import InMemorySessionService from google.adk.sessions.session import Session -from google.adk.tools.agent_tool import AgentTool from google.adk.tools.base_toolset import BaseToolset from google.adk.tools.function_tool import FunctionTool from google.adk.tools.long_running_tool import LongRunningFunctionTool @@ -1396,15 +1395,14 @@ async def test_runner_root_task_mode_writes_output_key_to_session_state(): @pytest.mark.asyncio async def test_runner_raises_on_root_llm_agent_with_single_turn_mode(): - """Runner raises ValueError if root LlmAgent runs with mode='single_turn'.""" + """Runner raises ValueError if root LlmAgent runs with mode='single_turn' before fetching session.""" session_service = InMemorySessionService() + spy = AsyncMock(wraps=session_service.get_session) + session_service.get_session = spy agent = LlmAgent(name="single_turn_agent", mode="single_turn") runner = Runner( app_name=TEST_APP_ID, agent=agent, session_service=session_service ) - await session_service.create_session( - app_name=TEST_APP_ID, user_id=TEST_USER_ID, session_id=TEST_SESSION_ID - ) with pytest.raises( ValueError, @@ -1422,6 +1420,8 @@ async def test_runner_raises_on_root_llm_agent_with_single_turn_mode(): ): pass + spy.assert_not_called() + @pytest.mark.asyncio async def test_chat_mode_fetches_session_once_per_turn():