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>>,
    pub resource_limits: Option<ResourceLimits>,
}

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.

resource_limits: Option<ResourceLimits>

Resource limits for concurrent LLM/tool calls and state size

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.

pub const fn with_resource_limits(self, limits: ResourceLimits) -> Self

Set resource limits for concurrent LLM/tool calls and state size

Examples

use juncture_core::config::{RunnableConfig, ResourceLimits};

let limits = ResourceLimits::new()
    .with_max_state_size_bytes(10 * 1024 * 1024);
let config = RunnableConfig::new()
    .with_resource_limits(limits);

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.