ADK for TypeScript: API Reference
    Preparing search index...

    Interface LlmAgentConfig

    The configuration options for creating an LLM-based agent.

    interface LlmAgentConfig {
        afterAgentCallback?: AfterAgentCallback;
        afterModelCallback?: AfterModelCallback;
        afterToolCallback?: AfterToolCallback;
        beforeAgentCallback?: BeforeAgentCallback;
        beforeModelCallback?: BeforeModelCallback;
        beforeToolCallback?: BeforeToolCallback;
        codeExecutor?: BaseCodeExecutor;
        contextCompactors?: BaseContextCompactor[];
        description?: string;
        disallowTransferToParent?: boolean;
        disallowTransferToPeers?: boolean;
        generateContentConfig?: GenerateContentConfig;
        globalInstruction?: string | InstructionProvider;
        includeContents?: "default" | "none";
        inputSchema?: LlmAgentSchema;
        instruction?: string | InstructionProvider;
        isolationScope?: string | true;
        mode?: "single_turn" | "task";
        model?: string | BaseLlm;
        name: string;
        outputKey?: string;
        outputSchema?: LlmAgentSchema;
        parentAgent?: BaseAgent<BaseAgentConfig>;
        planner?: BasePlanner;
        requestProcessors?: BaseLlmRequestProcessor[];
        rerunOnResume?: boolean;
        responseProcessors?: BaseLlmResponseProcessor[];
        retryConfig?: RetryConfig;
        stateSchema?: SchemaLike;
        subAgents?: BaseAgent<BaseAgentConfig>[];
        timeout?: number;
        tools?: ToolUnion[];
        waitForOutput?: boolean;
    }

    Hierarchy (View Summary)

    Properties

    afterAgentCallback?: AfterAgentCallback
    afterModelCallback?: AfterModelCallback

    Callbacks to be called after calling the LLM.

    afterToolCallback?: AfterToolCallback

    Callbacks to be called after calling the tool.

    beforeAgentCallback?: BeforeAgentCallback
    beforeModelCallback?: BeforeModelCallback

    Callbacks to be called before calling the LLM.

    beforeToolCallback?: BeforeToolCallback

    Callbacks to be called before calling the tool.

    codeExecutor?: BaseCodeExecutor

    Instructs the agent to make a plan and execute it step by step.

    contextCompactors?: BaseContextCompactor[]

    A list of context compactors to evaluate in priority order. Modifies the session history to keep context overhead within limits.

    description?: string

    Human-readable description (used when a node is exposed as a tool).

    disallowTransferToParent?: boolean

    Disallows LLM-controlled transferring to the parent agent.

    NOTE: Setting this to true also prevents this agent to continue reply to the end-user. This behavior prevents one-way transfer, in which end-user may be stuck with one agent that cannot transfer to other agents in the agent tree.

    disallowTransferToPeers?: boolean

    Disallows LLM-controlled transferring to the peer agents.

    generateContentConfig?: GenerateContentConfig

    The additional content generation configurations.

    Three fields are rejected by the constructor, because the agent owns them: tools (set them through tools), systemInstruction (through instruction) and responseSchema (through outputSchema). Every other field is forwarded to the model as given. That includes thinkingConfig, unless planner is a BuiltInPlanner with its own thinkingConfig: the planner's thinkingConfig then takes precedence.

    For example: use this config to adjust model temperature, configure safety settings, etc.

    globalInstruction?: string | InstructionProvider

    Instructions for all the agents in the entire agent tree.

    ONLY the globalInstruction in root agent will take effect.

    For example: use globalInstruction to make all agents have a stable identity or personality.

    Use GlobalInstructionPlugin instead.

    includeContents?: "default" | "none"

    Controls content inclusion in model requests.

    Options: default: Model receives relevant conversation history none: Model receives no prior history, operates solely on current instruction and input

    inputSchema?: LlmAgentSchema

    The input schema when agent is used as a tool.

    instruction?: string | InstructionProvider

    Instructions for the LLM model, guiding the agent's behavior.

    isolationScope?: string | true

    Runs this node's subtree in an isolated conversation scope: an agent inside it sees only session events carrying the same scope, plus untagged ones. true derives a scope per node run; a string is an explicit shared tag.

    mode?: "single_turn" | "task"

    The agent's execution mode when run as a workflow node.

    • single_turn (default): the agent runs once against the node input.
    • task: the agent is given a finish_task tool and runs a multi-round loop until it calls finish_task, whose arguments (conforming to outputSchema) become the node output. Mirrors Python's Agent(mode=...).
    model?: string | BaseLlm

    The model to use for the agent.

    name: string

    Canonical, unique-within-a-graph node name.

    outputKey?: string

    The key in session state to store the output of the agent.

    Typically use cases:

    • Extracts agent reply for later use, such as in tools, callbacks, etc.
    • Connects agents to coordinate with each other.
    outputSchema?: LlmAgentSchema

    The output schema when agent replies.

    parentAgent?: BaseAgent<BaseAgentConfig>
    planner?: BasePlanner

    Instructs the agent to make a plan and execute it step by step.

    NOTE: to use the model's built-in thinking features, set thinkingConfig on a BuiltInPlanner.

    requestProcessors?: BaseLlmRequestProcessor[]

    Processors to run before the LLM request is sent.

    rerunOnResume?: boolean

    If true, the node re-executes when a workflow resumes even if it already completed in a prior turn. Default false.

    responseProcessors?: BaseLlmResponseProcessor[]

    Processors to run after the LLM response is received.

    retryConfig?: RetryConfig

    Optional retry configuration for transient failures.

    stateSchema?: SchemaLike

    Optional schema validating relevant session state (Zod v3/v4 or genai Schema).

    subAgents?: BaseAgent<BaseAgentConfig>[]
    timeout?: number

    Maximum time, in seconds, for this node to complete.

    tools?: ToolUnion[]

    Tools available to this agent.

    waitForOutput?: boolean

    If true, the node only produces its output once all of its predecessors have triggered it (fan-in / join semantics). Default false.