A scoped single_turn LlmAgent node gets the workflow's user message as its first turn, before its node input #7944

import asyncio

import google.adk
from google.adk.agents import Context, LlmAgent
from google.adk.apps import App
from google.adk.models.base_llm import BaseLlm
from google.adk.models.llm_response import LlmResponse
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.adk.workflow import START, Workflow, node
from google.genai import types

WORKFLOW_MESSAGE = "workflow message"
NODE_INPUT = "node input: add 2 and 3"
model_calls: list[list[str]] = []


class RecordingLlm(BaseLlm):
    model: str = "recording"

    async def generate_content_async(self, llm_request, stream=False):
        model_calls.append(
            [f"{c.role}: {' | '.join(p.text for p in c.parts if p.text)}" for c in llm_request.contents]
        )
        yield LlmResponse(content=types.Content(role="model", parts=[types.Part(text="5")]))


def make_workflow(scope: str | None) -> Workflow:
    worker = LlmAgent(name="worker", model=RecordingLlm(), instruction="Add the numbers.", mode="single_turn")

    @node(rerun_on_resume=True)
    async def orchestrator(ctx: Context, node_input):
        yield await ctx.run_node(worker, node_input=NODE_INPUT, override_isolation_scope=scope)

    return Workflow(name="root", edges=[(START, orchestrator)])


async def run(scope: str | None) -> None:
    model_calls.clear()
    sessions = InMemorySessionService()
    runner = Runner(app=App(name="repro", root_agent=make_workflow(scope)), session_service=sessions)
    session = await sessions.create_session(app_name="repro", user_id="u")
    async for _ in runner.run_async(
        user_id="u", session_id=session.id, new_message=types.UserContent(WORKFLOW_MESSAGE)
    ):
        pass
    print(f"isolation scope={scope!r}: model saw {model_calls[0]}")


async def main():
    print("google-adk", google.adk.__version__)
    await run(None)
    await run("worker-scope")


asyncio.run(main())