Struct Runtime 

pub struct Runtime<S: State + Default> {
    pub previous: Option<Value>,
    pub checkpointer: Option<Arc<dyn CheckpointSaver>>,
    pub store: Option<Arc<dyn Store>>,
    pub core: Runtime<S>,
}

Runtime context for functional API workflows

Provides access to previous execution state, checkpointing, and storage during workflow execution. This type extends CoreRuntime with functional-API-specific features like previous value access.

Type Parameters

• S - State type (must implement State and Default)

Fields

• previous - Previous execution return value (for accumulation patterns)
• checkpointer - Checkpoint saver for state persistence
• store - Cross-thread persistent key-value store
• core - Underlying core runtime for advanced use cases

Examples

Accessing previous state

use juncture_core::func::Runtime;

async fn accumulating_workflow(
    state: CowState<MyState>,
    runtime: &CoreRuntime<MyState>,
) -> Result<MyStateUpdate, JunctureError> {
    // Access the functional runtime
    let func_runtime = Runtime::from_core(runtime);

    // Get the previous return value
    if let Some(previous) = &func_runtime.previous {
        let prev_output: Output = serde_json::from_value(previous.clone())
            .map_err(|e| JunctureError::execution(format!("Failed to deserialize previous: {}", e)))?;
        // Use previous value for accumulation
    }

    Ok(MyStateUpdate::default())
}

Using the store

use juncture_core::func::Runtime;

async fn workflow_with_store(
    state: CowState<MyState>,
    runtime: &CoreRuntime<MyState>,
) -> Result<MyStateUpdate, JunctureError> {
    let func_runtime = Runtime::from_core(runtime);

    if let Some(store) = &func_runtime.store {
        store.put("key", serde_json::json!("value")).await?;
    }

    Ok(MyStateUpdate::default())
}

Fields

previous: Option<Value>

Previous execution return value (for accumulation patterns)

When resuming from a checkpoint, this contains the return value from the previous execution. For first-time execution, this is None.

checkpointer: Option<Arc<dyn CheckpointSaver>>

Checkpoint saver for state persistence

When set, the workflow can save and restore intermediate state.

store: Option<Arc<dyn Store>>

Cross-thread persistent key-value store

Provides durable storage that survives across workflow executions.

core: Runtime<S>

Underlying core runtime

Provides access to advanced runtime features like heartbeat, execution metadata, and streaming.

Implementations

impl<S: State + Default> Runtime<S>

pub fn new() -> Self

where S: Default,

Create a new runtime with minimal configuration

pub fn from_core(core: &CoreRuntime<S>) -> Self

Create a functional runtime from a core runtime

This extracts functional-API-specific context from the core runtime, allowing entrypoint functions to access features like previous values.

pub fn from_entrypoint_config(config: &EntrypointConfig) -> Self

where S: Default,

Create a runtime from an entrypoint configuration

pub fn with_previous(self, previous: Value) -> Self

Set the previous execution value

pub fn with_checkpointer(self, checkpointer: Arc<dyn CheckpointSaver>) -> Self

Set the checkpointer

pub fn with_store(self, store: Arc<dyn Store>) -> Self

Set the store

pub fn with_core(self, core: CoreRuntime<S>) -> Self

Set the core runtime

Trait Implementations

impl<S: Clone + State + Default> Clone for Runtime<S>

fn clone(&self) -> Runtime<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: State + Default + Debug> Debug for Runtime<S>

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

Formats the value using the given formatter.

impl<S: State + Default> Default for Runtime<S>

fn default() -> Self

Returns the “default value” for a type.