ADK Workflow Node Output Sample

Overview

This sample demonstrates how to manage component outputs and structure data between nodes in an ADK Workflow.

When stringing nodes together, it's critical to know how the ADK framework passes data along edges. This sample shows:

Returning a raw string (it gets automatically wrapped in an Event).
Returning an explicit Event for more granular control over routes and state.
Generating a structured dictionary via Agent(output_schema=MyModel).
Automatically coercing that raw dictionary back into a fully formed Pydantic model simply by defining it as a type-hint parameter in the Python function.

Sample Inputs

cyberpunk future
gardening tips for beginners

Graph

text

         [ START ]
             |
             v
 [ generate_string_output ]
             |
             v
 [ generate_event_output ]
             |
             v
[ generate_pydantic_output ]
             |
             v
 [ consume_pydantic_output ]

How To

Return raw types (string, dict, list): The node runner will automatically wrap primitives in an Event(output=...).
python
```
def generate_string_output(node_input: str):
    return "Processed input: " + node_input
```

Return an Event explicitly: Use this when you also need to emit a route or modify ctx.state.

python

def generate_event_output(node_input: str):
    return Event(output=f"Wrapped output: {node_input}")

Generate structured data from an LLM: Pass a Pydantic class to the Agent's output_schema. The LLM returns a dictionary/JSON matching the structure.

python

class TopicDetails(BaseModel):
    title: str
    description: str
    category: str

generate_pydantic_output = Agent(
    name="generate_pydantic_output",
    output_schema=TopicDetails,
)

Consume structured data in a function: Simply type-hint the parameter. FunctionNode leverages Pydantic to parse the dictionary back into your fully accessible TopicDetails class automatically before your function starts running.
python
```
def consume_pydantic_output(node_input: TopicDetails):
    # Type coercion converts dict to model. Now you have .title, .category, etc.
    return f"Title: {node_input.title}"
```