Struct GraphConfig 

#[non_exhaustive]
pub struct GraphConfig {
    pub thread_id: String,
    pub checkpoint_id: Option<String>,
    pub recursion_limit: u32,
    pub max_concurrency: Option<usize>,
    pub configurable: HashMap<String, Value>,
    pub max_execution_time: Option<Duration>,
    pub retry_policy: Option<RetryPolicy>,
}

Configuration for a single graph execution.

Example

use pe_graph::GraphConfig;

let config = GraphConfig::default()
    .with_thread_id("my-thread")
    .with_recursion_limit(50);

NOTE: #[non_exhaustive] — will grow with timeout, retry policy, etc.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

thread_id: String

Conversation thread identifier. Used as the checkpoint key.

checkpoint_id: Option<String>

Resume from a specific past checkpoint (time travel).

recursion_limit: u32

Maximum supersteps before PeError::GraphRecursion. Default: 25.

Kept low to catch infinite loops early in agentic systems. Users can raise this for legitimately deep graphs.

max_concurrency: Option<usize>

Maximum parallel nodes per superstep. Default: unbounded.

Tokio’s thread pool naturally bounds actual parallelism. This provides an additional application-level limit.

configurable: HashMap<String, Value>

User-defined values readable inside nodes.

max_execution_time: Option<Duration>

Maximum wall-clock time for the entire graph execution.

The Pregel engine checks elapsed time at the start of each superstep. If exceeded, returns PeError::Timeout before running nodes. Default: None (no timeout).

retry_policy: Option<RetryPolicy>

Retry policy for failed nodes.

When set, nodes that return NodeResult::Error(e) where e.is_retryable() are retried up to max_attempts times with backoff delays. Only the individual failed node is retried, not the entire superstep. Default: None (no retries — errors are immediate).

Implementations

impl GraphConfig

pub fn with_thread_id(self, id: impl Into<String>) -> Self

Set the thread identifier for this execution.

pub fn with_recursion_limit(self, limit: u32) -> Self

Set the maximum number of supersteps before recursion error.

pub fn with_max_concurrency(self, n: usize) -> Self

Limit parallel node executions per superstep.

pub fn with_checkpoint_id(self, id: impl Into<String>) -> Self

Resume from a specific checkpoint.

pub fn with_max_execution_time(self, duration: Duration) -> Self

Set the maximum wall-clock time for the entire execution.

The engine checks this at the start of each superstep, before running any nodes. Running nodes are never cancelled mid-execution.

pub fn with_retry_policy(self, policy: RetryPolicy) -> Self

Set a retry policy for failed nodes.

When set, nodes returning retryable errors are retried individually with exponential backoff. Non-retryable errors fail immediately.

Example

use pe_graph::{GraphConfig, RetryPolicy};

let config = GraphConfig::default()
    .with_retry_policy(RetryPolicy::default());

Trait Implementations

impl Clone for GraphConfig

fn clone(&self) -> GraphConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GraphConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for GraphConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for GraphConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for GraphConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.