Struct RunnableConfig 

pub struct RunnableConfig {

    pub thread_id: Option<String>,
    pub checkpoint_id: Option<String>,
    pub recursion_limit: usize,
    pub max_parallel_tasks: usize,
    pub run_name: Option<String>,
    pub graph_name: Option<String>,
    pub run_id: Option<String>,
    pub checkpoint_ns: Option<CheckpointNamespace>,
    pub cache: Option<CacheConfig>,
    pub tags: Vec<String>,
    pub metadata: HashMap<String, Value>,
    pub cancellation_token: Option<CancellationToken>,
    pub budget: Option<BudgetConfig>,
    pub durability: Option<Durability>,
    pub node_finished_callback: Option<Arc<dyn Fn(&str) + Send + Sync>>,
    pub resume_value: Option<ResumeValue>,
    pub interrupt_before: Option<Vec<String>>,
    pub interrupt_after: Option<Vec<String>>,
    pub metrics_collector: Option<Arc<dyn MetricsCollector>>,
    pub callback_handler: Option<Arc<dyn GraphLifecycleCallback>>,
    pub llm_cache_policy: Option<CachePolicy>,
    pub heartbeat: Option<Heartbeat>,
    pub budget_tracker: Option<Arc<BudgetTracker>>,
}

Configuration for graph execution

Fields

thread_id: Option<String>

Thread ID for checkpoint isolation

checkpoint_id: Option<String>

Checkpoint ID to resume from (time-travel)

recursion_limit: usize

Maximum superstep count (default 25)

max_parallel_tasks: usize

Maximum parallel tasks (for bounded concurrency)

run_name: Option<String>

Run name for observability

graph_name: Option<String>

Graph name for observability (specified at graph construction time)

run_id: Option<String>

Unique run identifier for logging, stream resumption, and cancellation.

When None, the execution layer (CompiledGraph::stream, invoke, etc.) generates a new UUIDv4 automatically before creating the Pregel loop. Callers may set this explicitly to correlate multiple operations with the same run ID (e.g., for stream resumption or distributed tracing).

checkpoint_ns: Option<CheckpointNamespace>

Checkpoint namespace (for subgraph isolation)

cache: Option<CacheConfig>

Cache configuration

tags: Vec<String>

Tags for filtering

metadata: HashMap<String, Value>

User metadata

cancellation_token: Option<CancellationToken>

Cancellation token for aborting execution

budget: Option<BudgetConfig>

Budget configuration for execution limits

durability: Option<Durability>

Checkpoint durability mode

node_finished_callback: Option<Arc<dyn Fn(&str) + Send + Sync>>

Callback invoked when a node finishes execution

resume_value: Option<ResumeValue>

Resume value for HITL interrupt continuation

Supports single value, ID-based resume, and namespace-based resume for multi-interrupt workflows.

interrupt_before: Option<Vec<String>>

Nodes that should interrupt before execution (HITL)

interrupt_after: Option<Vec<String>>

Nodes that should interrupt after execution (HITL)

metrics_collector: Option<Arc<dyn MetricsCollector>>

Optional metrics collector for OpenTelemetry or in-memory metrics

callback_handler: Option<Arc<dyn GraphLifecycleCallback>>

Optional callback handler for graph lifecycle events

Receives notifications at key points during graph execution: node start/end/error, graph completion, and checkpoint saves. All methods have default no-op implementations.

llm_cache_policy: Option<CachePolicy>

LLM response cache policy for controlling key generation and TTL

heartbeat: Option<Heartbeat>

Optional heartbeat sender for long-running node liveness signals

When set by the execution engine, nodes can call config.heartbeat.as_ref().map(Heartbeat::ping) periodically to prevent idle timeout detection.

budget_tracker: Option<Arc<BudgetTracker>>

Runtime budget tracker shared across nodes for token/cost tracking

Set by the execution engine when a BudgetConfig is configured. Nodes can access this via Self::budget_tracker to report LLM token usage for automatic budget enforcement.

Implementations

impl RunnableConfig

pub fn new() -> Self

Create a new configuration with sensible defaults

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

Set the thread ID for checkpoint isolation

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

Set the checkpoint ID for time-travel resume

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

Set the run ID for stream resumption and observability correlation

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

Set the recursion limit (maximum superstep count)

pub const fn with_max_parallel_tasks(self, max: usize) -> Self

Set the maximum number of parallel tasks

pub fn with_run_name(self, name: impl Into<String>) -> Self

Set the run name for observability

pub fn with_graph_name(self, name: impl Into<String>) -> Self

Set the graph name for observability

pub fn with_checkpoint_ns(self, ns: CheckpointNamespace) -> Self

Set the checkpoint namespace for subgraph isolation

pub fn with_cache(self, cache: CacheConfig) -> Self

Set cache configuration

pub fn with_tag(self, tag: impl Into<String>) -> Self

Add a tag for filtering

pub fn with_metadata(self, key: impl Into<String>, value: Value) -> Self

Add metadata key-value pair

pub fn with_cancellation_token(self, token: CancellationToken) -> Self

Set the cancellation token for aborting execution

pub fn with_budget(self, budget: BudgetConfig) -> Self

Set the budget configuration for execution limits

pub fn with_interrupt_before(self, nodes: Vec<String>) -> Self

Set interrupt_before nodes (HITL - interrupt before node execution)

Examples

use juncture_core::config::RunnableConfig;

let config = RunnableConfig::new()
    .with_interrupt_before(vec!["human_input".to_string()]);

pub fn with_interrupt_after(self, nodes: Vec<String>) -> Self

Set interrupt_after nodes (HITL - interrupt after node execution)

Examples

use juncture_core::config::RunnableConfig;

let config = RunnableConfig::new()
    .with_interrupt_after(vec!["confirmation".to_string()]);

pub fn with_metrics_collector( self, collector: Arc<dyn MetricsCollector>, ) -> Self

Set the metrics collector for observability

Examples

use std::sync::Arc;
use juncture_core::config::RunnableConfig;
use juncture_core::observability::MetricsCollector;

let collector: Arc<dyn MetricsCollector> = /* ... */;
let config = RunnableConfig::new()
    .with_metrics_collector(collector);

pub fn with_callback_handler( self, handler: Arc<dyn GraphLifecycleCallback>, ) -> Self

Set the callback handler for graph lifecycle events

Examples

use std::sync::Arc;
use juncture_core::config::RunnableConfig;
use juncture_core::observability::GraphLifecycleCallback;

let handler: Arc<dyn GraphLifecycleCallback> = /* ... */;
let config = RunnableConfig::new()
    .with_callback_handler(handler);

pub fn with_llm_cache_policy(self, policy: LlmCachePolicy) -> Self

Set the LLM response cache policy

pub const fn budget_tracker(&self) -> Option<&Arc<BudgetTracker>>

Get a reference to the budget tracker, if configured

Nodes can call this to report LLM token usage for automatic budget enforcement during graph execution.

Trait Implementations

impl Clone for RunnableConfig

fn clone(&self) -> RunnableConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RunnableConfig

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

Formats the value using the given formatter.

impl Default for RunnableConfig

fn default() -> RunnableConfig

Returns the “default value” for a type.