LlmAgent
LLM-based Agent.
When this agent is a sub-agent and the parent transfers control to it via transfer_to_agent, the runner decides who handles the next user turn based on the disallowTransferToParent / disallowTransferToPeers flags inherited from BaseAgent - see those flags for the full dispatch rules.
Constructors
Types
Properties
List of callbacks to run after the agent executes.
List of callbacks to run after each model call.
List of callbacks to run after each tool call.
List of callbacks to run before the agent executes.
List of callbacks to run before each model call.
List of callbacks to run before each tool call.
The node's retry policy and execution timeout.
What the node does, for humans and for a model that may call it.
When true, the framework will not route the next user turn back to this agent after the parent transfers control to it; instead the next turn falls back to the root agent. Set this on utility sub-agents the parent calls and returns from (translators, summarizers, classifiers). Leave at the default false for sub-agents that should keep handling follow-up turns directly (e.g. billing, support).
When true, prevents this agent from transferring sideways to a peer agent under the same parent. Typically set together with disallowTransferToParent on one-shot utility agents. Violations are surfaced by the runner as IllegalArgumentException.
The additional content generation configurations.
Controls how prior conversation history is included in the model request. Defaults to IncludeContents.DEFAULT, which includes the relevant conversation history. Set to IncludeContents.NONE to exclude prior history; the model then receives only the current turn (the most recent user input or other-agent reply, plus any tool calls/responses produced within that turn). The system instruction and tools are preserved in both modes.
The input schema of the agent.
Instruction guiding the agent's behavior. Use one of: - Instruction("text") for a literal string (the most common case), - Instruction(content) for a pre-built, possibly multimodal Content, or - Instruction { ctx -> ... } for a Instruction.Provider resolved per turn.
The maximum number of steps this agent runs within a single invocation, where a step is one model call plus any tool calls or transfers it triggers. Once the cap is reached the agent stops emitting further events, even if it has not yet produced a final response. Defaults to null, meaning no cap: the agent keeps stepping until it produces a final response or the invocation otherwise ends (which can run unbounded). Mirrors the Java ADK LlmAgent.maxSteps.
List of callbacks to run when a model call fails.
List of callbacks to run when a tool call fails.
The key in session state to store the final text response of the agent. When set, the agent's concatenated text output (excluding parts marked as thoughts) is written to event.actions.stateDelta[outputKey] on each final-response event, which the session service then merges into the session state.
The schema the agent's final response must conform to. Only top-level object schemas are supported (matching the Java ADK; the Python ADK additionally supports list/primitive output schemas). When set, the agent asks the model to return JSON matching this schema and validates the final response against it before saving it to outputKey. If the agent also has tools (including the framework's transfer_to_agent tool when sub-agents/peers are reachable), the schema is applied directly on models that support a response schema together with tools; on models that do not (e.g. Gemini 2.x), the framework falls back to a set_model_response tool to collect the structured output.
Whether the node runs only once every predecessor has completed, receiving all their outputs keyed by node name. A fan-in node overrides this to true.
On resume, whether to run the node again from scratch rather than completing it with the resuming answer as its output.
Declares the state keys the node uses. Child nodes inherit it unless they declare their own.
Static instruction content sent literally as system instruction at the beginning. This field is for content that never changes. It's sent directly to the model without any processing or variable substitution.
Whether the node stays re-triggerable until it produces an output or a route, instead of completing when runNode returns. A node that never produces either then waits forever, which is a graph-authoring error.
Functions
Runs the node and emits its events. It drives runNode and normalizes each raw emission into an Event, so every node behaves the same way at its edges: null and Unit are skipped, an Event passes through with its output validated (a message-as-output event's content is not), and any other value becomes the output.
Public entry point for executing the agent asynchronously (text-based).
Runs this agent as a graph node by driving its runAsync lifecycle, so an agent placed in a workflow graph executes exactly as it would under a runner. Its events are forwarded as the node's output and its author is tracked; the node runner stamps each event's path.