Struct GraphAgentBuilder 

pub struct GraphAgentBuilder { /* private fields */ }

Available on crate feature graph only.

Builder for GraphAgent

Implementations

impl GraphAgentBuilder

pub fn new(name: &str) -> GraphAgentBuilder

Create a new builder

pub fn description(self, desc: &str) -> GraphAgentBuilder

Set description

pub fn state_schema(self, schema: StateSchema) -> GraphAgentBuilder

Set state schema

pub fn channels(self, channels: &[&str]) -> GraphAgentBuilder

Add channels to state schema

pub fn node<N>(self, node: N) -> GraphAgentBuilder

where N: Node + 'static,

Add a node

pub fn node_fn<F, Fut>(self, name: &str, func: F) -> GraphAgentBuilder

where F: Fn(NodeContext) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<NodeOutput, GraphError>> + Send + 'static,

Add a function as a node

pub fn edge(self, source: &str, target: &str) -> GraphAgentBuilder

Add a direct edge

pub fn conditional_edge<F, I>( self, source: &str, router: F, targets: I, ) -> GraphAgentBuilder

where F: Fn(&HashMap<String, Value>) -> String + Send + Sync + 'static, I: IntoIterator<Item = (&'static str, &'static str)>,

Add a conditional edge

pub fn checkpointer<C>(self, checkpointer: C) -> GraphAgentBuilder

where C: Checkpointer + 'static,

Set checkpointer

pub fn checkpointer_arc( self, checkpointer: Arc<dyn Checkpointer>, ) -> GraphAgentBuilder

Set checkpointer with Arc

pub fn interrupt_before(self, nodes: &[&str]) -> GraphAgentBuilder

Set nodes to interrupt before

pub fn interrupt_after(self, nodes: &[&str]) -> GraphAgentBuilder

Set nodes to interrupt after

pub fn max_concurrency(self, limit: usize) -> GraphAgentBuilder

Set recursion limit Cap how many nodes execute concurrently within one super-step.

See CompiledGraph::with_max_concurrency.

pub fn recursion_limit(self, limit: usize) -> GraphAgentBuilder

pub fn node_timeout( self, node_name: &str, policy: TimeoutPolicy, ) -> GraphAgentBuilder

Set a timeout policy for a specific node.

The policy is applied when the named node executes, enforcing wall-clock and/or idle timeouts with the configured recovery action.

Example

use std::time::Duration;
use adk_graph::timeout::{TimeoutPolicy, OnTimeout};

let agent = GraphAgent::builder("my_graph")
    .node_timeout("slow_node", TimeoutPolicy {
        run_timeout: Some(Duration::from_secs(10)),
        idle_timeout: None,
        on_timeout: OnTimeout::Fail,
    })
    .build()?;

pub fn default_timeout(self, policy: TimeoutPolicy) -> GraphAgentBuilder

Set a default timeout policy applied to all nodes without an explicit override.

Nodes that have a per-node policy set via node_timeout will use their specific policy instead of this default.

Example

use std::time::Duration;
use adk_graph::timeout::{TimeoutPolicy, OnTimeout};

let agent = GraphAgent::builder("my_graph")
    .default_timeout(TimeoutPolicy {
        run_timeout: Some(Duration::from_secs(30)),
        idle_timeout: Some(Duration::from_secs(5)),
        on_timeout: OnTimeout::Skip,
    })
    .build()?;

pub fn mark_deferred( self, name: &str, config: DeferredNodeConfig, ) -> GraphAgentBuilder

Add a deferred (fan-in barrier) node to the graph.

A deferred node waits for all upstream parallel paths to complete before executing. The provided function is wrapped as a FunctionNode and the DeferredNodeConfig controls how upstream outputs are merged and how long the node waits for all paths.

Arguments

• name - The name of the deferred node.
• func - The async function to execute once all upstream paths complete.
• config - Configuration controlling merge strategy and fan-in timeout.

Example

use std::time::Duration;
use adk_graph::deferred::{DeferredNodeConfig, MergeStrategy};
use adk_graph::node::NodeOutput;

let agent = GraphAgent::builder("scatter_gather")
    .deferred_node("aggregator", |_ctx| async {
        Ok(NodeOutput::new().with_update("status", serde_json::json!("merged")))
    }, DeferredNodeConfig {
        merge_strategy: MergeStrategy::Collect,
        fan_in_timeout: Some(Duration::from_secs(30)),
    })
    .build()?;

Configure fan-in for a node already added with node.

deferred_node both adds and configures a node, so a custom Node added through node had no way to set a merge strategy or a fan-in timeout.

A node reached by more than one unconditional edge is deferred automatically; this overrides that default.

pub fn deferred_node<F, Fut>( self, name: &str, func: F, config: DeferredNodeConfig, ) -> GraphAgentBuilder

where F: Fn(NodeContext) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<NodeOutput, GraphError>> + Send + 'static,

pub fn node_cache( self, name: &str, policy: NodeCachePolicy, ) -> GraphAgentBuilder

Available on crate feature node-cache only.

Set a cache policy for a specific node.

When a node has a cache policy, its execution results are cached keyed by a blake3 hash of the node name and input state. Subsequent executions with identical inputs return the cached result without re-executing the node.

Arguments

• name — the name of the node to cache
• policy — the cache policy specifying backend and TTL

Example

use std::time::Duration;
use adk_graph::cache::{CacheBackend, NodeCachePolicy};

let agent = GraphAgent::builder("cached_graph")
    .node_cache("expensive_node", NodeCachePolicy {
        backend: CacheBackend::InMemory { max_entries: 128 },
        ttl: Some(Duration::from_secs(300)),
    })
    .build()?;

pub fn input_mapper<F>(self, mapper: F) -> GraphAgentBuilder

where F: Fn(&dyn InvocationContext) -> HashMap<String, Value> + Send + Sync + 'static,

Set custom input mapper

pub fn output_mapper<F>(self, mapper: F) -> GraphAgentBuilder

where F: Fn(&HashMap<String, Value>) -> Vec<Event> + Send + Sync + 'static,

Set custom output mapper

pub fn before_agent_callback<F, Fut>(self, callback: F) -> GraphAgentBuilder

where F: Fn(Arc<dyn InvocationContext>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<(), AdkError>> + Send + 'static,

Set before agent callback

pub fn after_agent_callback<F, Fut>(self, callback: F) -> GraphAgentBuilder

where F: Fn(Arc<dyn InvocationContext>, Event) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<(), AdkError>> + Send + 'static,

Set after agent callback

Note: The callback receives a cloned Event to avoid lifetime issues.

pub fn build(self) -> Result<GraphAgent, GraphError>

Build the GraphAgent