This sample demonstrates how to use ctx.run_node(node, use_as_output=True) to delegate a node's output to a dynamically executed child node.

When use_as_output=True is set, the child node's output replaces the parent's output. The parent's own output event is suppressed to avoid duplication, and the child's output flows downstream through the graph as if the parent produced it.

The child node can be any node type — this sample uses a single_turn LLM agent (summarizer) as the delegated child.

• The quick brown fox jumped over the lazy dog near the riverbank on a warm summer afternoon

graph TD
    START --> orchestrate
    orchestrate -.->|delegates output via ctx.run_node| summarizer
    summarizer --> finalize

1. Define the child node: The child can be a function or an LLM agent. Its output becomes the parent's output and flows to downstream nodes.

   from google.adk import Agent
   
   summarizer = Agent(
       name='summarizer',
       model='gemini-2.5-flash',
       instruction='Summarize the following text in one sentence.',
   )

2. Mark the orchestrator as rerun_on_resume: The parent node that calls ctx.run_node must use @node(rerun_on_resume=True).

   from google.adk.workflow import node
   
   @node(rerun_on_resume=True)
   async def orchestrate(ctx: Context, node_input: str) -> str:
       return await ctx.run_node(
           summarizer, node_input=node_input, use_as_output=True
       )

3. Downstream receives delegated output: The finalize node receives the LLM's summary as its node_input, not the parent's.

   def finalize(node_input: str) -> str:
       return f'final: {node_input}'