Juncture

https://docs.rs/juncture/0.3.1/juncture/
Admin
Juncture is a Rust framework for building stateful, multi-actor LLM applications and agent workflows...
Tokens:596,722
Snippets:9,923
Trust Score:9.1
Update:1 month ago
Show doc for...
Tokens:
Raw
### Start background sweep task

Source: https://docs.rs/juncture/0.3.1/juncture/prelude/store/struct.MemoryStore.html?search=

Shows how to initialize a MemoryStore with TTL configuration and start a background task for periodic cleanup.

```rust
use juncture_core::store::{MemoryStore, TTLConfig};
use std::{time::Duration, sync::Arc};

let store = Arc::new(MemoryStore::new().with_ttl_config(TTLConfig {
    default_ttl: Some(Duration::from_secs(300)),
    refresh_on_read: true,
    ..Default::default()
}));

// Start background sweep task
let _sweep_handle = store.start_sweep_task();

// Store continues to work, sweep task runs in background
// The task will run until _sweep_handle is dropped or aborted
```

--------------------------------

### Set Entry Point

Source: https://docs.rs/juncture/0.3.1/juncture/graph/struct.StateGraph.html

Defines the starting node for the graph, equivalent to adding an edge from the START node.

```rust
graph.set_entry_point("start_node");
```

--------------------------------

### Command Initialization Examples

Source: https://docs.rs/juncture/0.3.1/juncture/command/struct.Command.html?search=

Basic imports for utilizing Command functionality in a project.

```rust
use juncture_core::Command;
use serde_json::json;
```

--------------------------------

### Initialize LlmSummarizer

Source: https://docs.rs/juncture/0.3.1/juncture/memory/struct.LlmSummarizer.html?search=

Example showing how to instantiate an LlmSummarizer with a ChatOpenAI model.

```rust
use juncture::memory::LlmSummarizer;
use juncture::llm::ChatOpenAI;
use std::sync::Arc;

let model = ChatOpenAI::new("sk-...");
let summarizer = LlmSummarizer::new(model, 500);
```

--------------------------------

### Initialize CircuitBreakerConfig

Source: https://docs.rs/juncture/0.3.1/juncture/graph/struct.CircuitBreakerConfig.html

Example of creating a new configuration instance.

```rust
use juncture_core::graph::CircuitBreakerConfig;
use std::time::Duration;

let config = CircuitBreakerConfig::new(5, Duration::from_secs(30));
assert_eq!(config.failure_threshold, 5);
```

--------------------------------

### Compile a graph with configuration

Source: https://docs.rs/juncture/0.3.1/juncture/graph/struct.CompileConfig.html

Example showing how to instantiate CompileConfig and use it to compile a graph.

```rust
use juncture_core::graph::CompileConfig;

let config = CompileConfig {
    interrupt_before: vec!["human_review".into()],
    interrupt_after: vec!["llm_call".into()],
};
let compiled = graph.compile_with_config(config)?;
```

--------------------------------

### RunnableConfig Usage

Source: https://docs.rs/juncture/0.3.1/juncture/prelude/struct.RunnableConfig.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example of initializing a RunnableConfig with custom resource limits.

```APIDOC
## RunnableConfig Initialization

### Description
Initializes a new `RunnableConfig` instance and applies resource limits such as maximum state size.

### Example
```rust
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);
```
```

--------------------------------

### SyncAsyncFuture Usage Examples

Source: https://docs.rs/juncture/0.3.1/juncture/enum.SyncAsyncFuture.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates creating and awaiting both synchronous and asynchronous results using SyncAsyncFuture.

```rust
use juncture_core::pregel::types::SyncAsyncFuture;

// Synchronous (cache hit)
let ready = SyncAsyncFuture::ready(42);
assert!(ready.is_ready());
assert_eq!(ready.result().await?, 42);

// Asynchronous (needs computation)
let pending = SyncAsyncFuture::pending(async { Ok(99) });
assert!(!pending.is_ready());
assert_eq!(pending.result().await?, 99);
```

--------------------------------

### Using ValidationNode

Source: https://docs.rs/juncture/0.3.1/juncture/tools/struct.ValidationNode.html?search=

Example demonstrating how to initialize a ValidationNode with token limits and a custom validation closure.

```rust
use juncture::tools::ValidationNode;
use juncture_core::state::messages::Message;

let validator = ValidationNode::new()
    .with_max_tokens(100_000)
    .with_validator(|messages| {
        // Custom validation logic
        if messages.len() > 1000 {
            return Err(ToolError::validation_failed(vec!["Too many messages".to_string()]));
        }
        Ok(())
    });

validator.validate(&messages)?;
```

--------------------------------

### START

Source: https://docs.rs/juncture/0.3.1/juncture/prelude/constant.START.html

The START constant is a sentinel value used to define the virtual start node when configuring entry points in a StateGraph.

```APIDOC
## Constant: START

### Description
Sentinel constant for graph entry point. This is used as the virtual start node when setting entry points via `super::StateGraph::set_entry_point`.

### Signature
`pub const START: &'static str;`
```

--------------------------------

### Define the START constant

Source: https://docs.rs/juncture/0.3.1/juncture/constant.START.html

This constant represents the virtual start node for graph entry points.

```rust
pub const START: &'static str;
```

--------------------------------

### Initialize Runtime

Source: https://docs.rs/juncture/0.3.1/juncture/prelude/runtime/struct.Runtime.html

Demonstrates creating a Runtime instance with default settings or a custom context.

```rust
use juncture_core::Runtime;
use std::sync::Arc;

// Simple runtime with no context
let runtime = Runtime::<()>::new();

// Runtime with custom context
struct MyContext { user_id: String }
let runtime = Runtime::with_context(MyContext { user_id: "123".to_string() });
```

--------------------------------

### Implement StatefulTool with ToolRuntime

Source: https://docs.rs/juncture/0.3.1/juncture/tools/struct.ToolRuntime.html

Example demonstrating how to access state, configuration, and the store within a tool's invocation method.

```rust
use juncture::tools::{StatefulTool, ToolRuntime};
use juncture_core::{State, RunnableConfig};
use async_trait::async_trait;

struct MyStatefulTool;

#[async_trait]
impl<S: State + 'static> StatefulTool<S> for MyStatefulTool {
    async fn invoke_with_runtime(
        &self,
        input: serde_json::Value,
        runtime: &ToolRuntime<S>,
    ) -> Result<String, ToolError> {
        // Access state
        let state = &runtime.state;
        let config = runtime.config();

        // Access store if available
        if let Some(store) = runtime.store() {
            let item = store.get("namespace", "key").await?;
        }

        Ok("Result".to_string())
    }
}
```

--------------------------------

### Example Usage of create_react_agent_with_config

Source: https://docs.rs/juncture/0.3.1/juncture/prebuilt/fn.create_react_agent_with_config.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates initializing a ReAct agent with a mock model and custom system message configuration.

```rust
use juncture::llm::MockChatModel;
use juncture::prebuilt::{create_react_agent_with_config, ReactAgentConfig};
use juncture::tools::Tool;

let model = MockChatModel::new("gpt-4").with_response("Hello!");
let tools: Vec<Box<dyn Tool>> = vec![];
let config = ReactAgentConfig {
    system_message: Some("You are a helpful assistant.".to_string()),
    ..Default::default()
};

let graph = create_react_agent_with_config(model, tools, config)?;
```

--------------------------------

### get

Source: https://docs.rs/juncture/0.3.1/juncture/prelude/state/struct.CowState.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves a read-only reference to the current state.

```APIDOC
## pub fn get(&self) -> &S

### Description
Get current state (read-only).
```

--------------------------------

### Example Usage of create_agent_with_config

Source: https://docs.rs/juncture/0.3.1/juncture/prebuilt/fn.create_agent_with_config.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates initializing a ReAct agent with a mock model and a custom system message configuration.

```rust
use juncture::llm::MockChatModel;
use juncture::prebuilt::{create_agent_with_config, ReactAgentConfig};
use juncture::tools::Tool;

let model = MockChatModel::new("gpt-4").with_response("Hello!");
let tools: Vec<Box<dyn Tool>> = vec![];
let config = ReactAgentConfig {
    system_message: Some("You are a helpful assistant.".to_string()),
    ..Default::default()
};

let graph = create_agent_with_config(model, tools, config)?;
```

--------------------------------

### get

Source: https://docs.rs/juncture/0.3.1/juncture/prelude/state/channel/struct.DeltaChannel.html?search=

Retrieves the current value stored in the channel.

```APIDOC
## fn get(&self) -> &T

### Description
Get the current value.
```

--------------------------------

### Initialize ChatOpenAI Client

Source: https://docs.rs/juncture/0.3.1/juncture/llm/struct.ChatOpenAI.html

Shows how to create a new client instance using an API key or environment variables.

```rust
use juncture::llm::ChatOpenAI;

let model = ChatOpenAI::new("sk-...")?;
```

```rust
use juncture::llm::ChatOpenAI;

let model = ChatOpenAI::from_env()?;
```

--------------------------------

### Configure ResourceLimits

Source: https://docs.rs/juncture/0.3.1/juncture/config/struct.ResourceLimits.html?search=std%3A%3Avec

Example showing how to instantiate ResourceLimits and set the maximum state size in bytes.

```rust
use juncture_core::config::ResourceLimits;

let limits = ResourceLimits::new()
    .with_max_state_size_bytes(10 * 1024 * 1024); // 10 MB
```

--------------------------------

### Arc::weak_count

Source: https://docs.rs/juncture/0.3.1/juncture/prelude/prebuilt/type.ModelSelector.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets the number of Weak pointers to this allocation.

```APIDOC
## pub fn weak_count(this: &Arc<T, A>) -> usize

### Description
Gets the number of `Weak` pointers to this allocation. Note that another thread can change the weak count at any time.
```

--------------------------------

### WebFetchTool::new

Source: https://docs.rs/juncture/0.3.1/juncture/tools/builtin/struct.WebFetchTool.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new instance of WebFetchTool with default settings (15s timeout, 500KB max size).

```APIDOC
### pub const fn new() -> Self

Creates a new `WebFetchTool` with default settings.
```

--------------------------------

### Converting to AgentEntry

Source: https://docs.rs/juncture/0.3.1/juncture/prebuilt/trait.IntoAgentEntry.html

Example showing how to convert a CompiledGraph into an AgentEntry.

```rust
use juncture::prebuilt::{IntoAgentEntry, AgentEntry};
use juncture::prebuilt::MessagesState;

let graph: CompiledGraph<MessagesState> = create_react_agent(...)?;
let entry: AgentEntry = graph.into_agent_entry();
```

--------------------------------

### Initialize and Query PricingTable

Source: https://docs.rs/juncture/0.3.1/juncture/llm/struct.PricingTable.html

Demonstrates creating a default pricing table and retrieving input/output pricing for a specific model.

```rust
use juncture::llm::PricingTable;

let pricing = PricingTable::default();
if let Some((input_price, output_price)) = pricing.get("claude-3-opus-20240229") {
    // Use pricing information
    let _ = (input_price, output_price);
}
```

--------------------------------

### Configure initial backoff

Source: https://docs.rs/juncture/0.3.1/juncture/llm/struct.RetryingModel.html

Sets the starting duration for exponential backoff.

```rust
use juncture::llm::{MockChatModel, RetryingModel};
use std::time::Duration;

let base_model = MockChatModel::new("gpt-4");
let model = RetryingModel::new(base_model)
    .initial_backoff(Duration::from_secs(2));
```

--------------------------------

### Runtime::new

Source: https://docs.rs/juncture/0.3.1/juncture/func/struct.Runtime.html?search=std%3A%3Avec

Creates a new runtime instance with minimal configuration.

```APIDOC
## pub fn new() -> Runtime<S>

### Description
Creates a new runtime with minimal configuration.

### Returns
- **Runtime<S>** - A new instance of the Runtime.
```

--------------------------------

### fn get(&self) -> &T

Source: https://docs.rs/juncture/0.3.1/juncture/prelude/trait.Channel.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the current value stored in the channel.

```APIDOC
### fn get(&self) -> &T

Returns a reference to the current value.
```

--------------------------------

### get

Source: https://docs.rs/juncture/0.3.1/juncture/prelude/store/trait.Store.html

Retrieves an item from the store based on the provided namespace and key.

```APIDOC
## fn get(namespace: &str, key: &str)

### Description
Retrieves an item from the store. Returns the item if found, or None if it does not exist.

### Parameters
- **namespace** (str) - Required - Namespace path
- **key** (str) - Required - Item key within namespace
```

--------------------------------

### Arc::strong_count

Source: https://docs.rs/juncture/0.3.1/juncture/prelude/prebuilt/type.ModelSelector.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets the number of strong (Arc) pointers to this allocation.

```APIDOC
## pub fn strong_count(this: &Arc<T, A>) -> usize

### Description
Gets the number of strong (`Arc`) pointers to this allocation. Note that another thread can change the strong count at any time.
```

--------------------------------

### BudgetTracker::new

Source: https://docs.rs/juncture/0.3.1/juncture/prelude/pregel/struct.BudgetTracker.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new instance of BudgetTracker with the provided configuration.

```APIDOC
## pub fn new(config: BudgetConfig) -> BudgetTracker

### Description
Initializes a new budget tracker with the specified configuration settings.

### Parameters
- **config** (BudgetConfig) - Required - The configuration object defining limits for tokens, duration, etc.
```

--------------------------------

### as_ref

Source: https://docs.rs/juncture/0.3.1/juncture/prelude/llm/type.BoxStream.html?search=u32+-%3E+bool

Gets a shared reference to the pinned value this Pin points to.

```APIDOC
## pub fn as_ref(&self) -> Pin<&<Ptr as Deref>::Target>

### Description
Gets a shared reference to the pinned value this `Pin` points to. This is a safe way to go from `&Pin<Pointer<T>>` to `Pin<&T>`.

### Parameters
- **self** (&self) - The Pin instance.
```

--------------------------------

### Basic usage of compile_entrypoint

Source: https://docs.rs/juncture/0.3.1/juncture/fn.compile_entrypoint.html

Demonstrates wrapping an async workflow function into an executable graph with a memory-based checkpointer.

```rust
use juncture_core::func::compile_entrypoint;
use juncture_core::checkpoint::MemorySaver;
use juncture_core::state::CowState;
use juncture_core::runtime::Runtime as CoreRuntime;
use juncture_core::JunctureError;

async fn my_workflow(
    state: CowState<MyState>,
    runtime: &CoreRuntime<MyState>,
) -> Result<MyStateUpdate, JunctureError> {
    Ok(MyStateUpdate::default())
}

let graph = compile_entrypoint::<MyState, Input, Output, _>(
    my_workflow,
    Some(Arc::new(MemorySaver::new()))
)?;

let result = graph.invoke(input, &config).await?;
```

--------------------------------

### Get tracker length

Source: https://docs.rs/juncture/0.3.1/juncture/pregel/struct.FieldVersionTracker.html

Returns the total number of fields being tracked.

```rust
use juncture_core::pregel::scheduler::FieldVersionTracker;

let tracker = FieldVersionTracker::new(5);
assert_eq!(tracker.len(), 5);
```

--------------------------------

### WebFetchTool Configuration Methods

Source: https://docs.rs/juncture/0.3.1/juncture/tools/builtin/struct.WebFetchTool.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for initializing and configuring the WebFetchTool instance.

```rust
pub const fn new() -> Self
```

```rust
pub const fn with_timeout(self, secs: u64) -> Self
```

```rust
pub const fn with_max_size(self, bytes: usize) -> Self
```

--------------------------------

### Register Callback Handler

Source: https://docs.rs/juncture/0.3.1/juncture/observability/trait.GraphLifecycleCallback.html

Example of injecting a GraphLifecycleCallback implementation into a RunnableConfig.

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

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

--------------------------------

### Implementing a Context-Aware Stateful Tool

Source: https://docs.rs/juncture/0.3.1/juncture/tools/trait.StatefulTool.html

Example implementation of a tool that utilizes the ToolRuntime to access persistent storage and configuration.

```rust
use juncture::tools::{StatefulTool, ToolRuntime, ToolError};
use juncture_core::State;
use async_trait::async_trait;
use serde_json::json;

struct ContextAwareSearchTool;

#[async_trait]
impl<S: State + 'static> StatefulTool<S> for ContextAwareSearchTool {
    async fn invoke_with_runtime(
        &self,
        input: serde_json::Value,
        runtime: &ToolRuntime<S>,
    ) -> Result<String, ToolError> {
        // Access the persistent store for cross-thread memory
        if let Some(store) = runtime.store() {
            let _item = store.get("namespace", "key").await
                .map_err(|e| ToolError::execution_failed(e.to_string()))?;
        }

        Ok(format!("Searched with config: {:?}", runtime.config()))
    }

    fn name(&self) -> &'static str {
        "context_aware_search"
    }

    fn description(&self) -> &'static str {
        "Searches using graph state context"
    }

    fn schema(&self) -> serde_json::Value {
        json!({"type": "object"})
    }
}
```

--------------------------------

### Initialize RunnableConfig with Resource Limits

Source: https://docs.rs/juncture/0.3.1/juncture/config/struct.RunnableConfig.html?search=u32+-%3E+bool

Demonstrates how to create a new RunnableConfig instance and apply custom resource limits.

```rust
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);
```

--------------------------------

### Initialize LlmFactExtractor

Source: https://docs.rs/juncture/0.3.1/juncture/memory/struct.LlmFactExtractor.html?search=

Example showing how to instantiate an LlmFactExtractor with a ChatOpenAI model.

```rust
use juncture::memory::LlmFactExtractor;
use juncture::llm::ChatOpenAI;

let model = ChatOpenAI::new("sk-...");
let extractor = LlmFactExtractor::new(model);
```

--------------------------------

### WebFetchTool Methods

Source: https://docs.rs/juncture/0.3.1/juncture/tools/builtin/struct.WebFetchTool.html?search=u32+-%3E+bool

Methods for initializing and configuring the WebFetchTool instance.

```APIDOC
## pub const fn new() -> Self

### Description
Creates a new `WebFetchTool` instance with default settings (15s timeout, 500KB max size).

## pub const fn with_timeout(self, secs: u64) -> Self

### Description
Configures the request timeout in seconds.

## pub const fn with_max_size(self, bytes: usize) -> Self

### Description
Sets the maximum response size in bytes for the fetch operation.
```

--------------------------------

### Initialize BudgetTracker

Source: https://docs.rs/juncture/0.3.1/juncture/pregel/struct.BudgetTracker.html?search=

Create a new instance of BudgetTracker using a BudgetConfig configuration.

```rust
use juncture_core::pregel::budget::{BudgetTracker, BudgetConfig};
use std::time::Duration;

let config = BudgetConfig::new()
    .with_max_tokens(1000)
    .with_max_duration(Duration::from_secs(60));
let tracker = BudgetTracker::new(config);
```

--------------------------------

### Initialize a MemorySaver

Source: https://docs.rs/juncture/0.3.1/juncture/checkpoint/trait.CheckpointSaver.html

Example of initializing a MemorySaver implementation of the CheckpointSaver trait.

```rust
use juncture_core::CheckpointSaver;
use juncture_checkpoint::MemorySaver;

let saver = MemorySaver::new();
// Use saver as a CheckpointSaver trait object...
```

--------------------------------

### Runtime::new

Source: https://docs.rs/juncture/0.3.1/juncture/prelude/runtime/struct.Runtime.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new runtime instance with minimal configuration. Requires the context type C to implement Default.

```APIDOC
## Runtime::new

### Description
Creates a new runtime with minimal configuration.

### Signature
`pub fn new() -> Runtime<C> where C: Default`
```

--------------------------------

### ToolRuntime::emit_tool_started

Source: https://docs.rs/juncture/0.3.1/juncture/prelude/struct.ToolRuntime.html?search=std%3A%3Avec

Emits a lifecycle event indicating that a tool has started execution.

```APIDOC
## ToolRuntime::emit_tool_started

### Description
Sends a ToolsEvent::ToolStarted through the tools event channel if configured.

### Parameters
- **tool_name** (&str) - Name of the tool being started
- **node** (&str) - Node name where the tool is executing
- **input** (Value) - Tool input as JSON value
```

--------------------------------

### MemoryStore::start_sweep_task

Source: https://docs.rs/juncture/0.3.1/juncture/prelude/store/struct.MemoryStore.html

Starts a background task for periodic cleanup of expired items.

```APIDOC
## pub fn start_sweep_task(self: Arc<MemoryStore>) -> JoinHandle<()>

### Description
Start the background sweep task for periodic expired item cleanup. The task runs periodically based on the sweep_interval defined in the TTL configuration.
```

--------------------------------

### as_mut

Source: https://docs.rs/juncture/0.3.1/juncture/prelude/llm/type.BoxStream.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets a mutable reference to the pinned value this Pin<Ptr> points to.

```APIDOC
## pub fn as_mut(&mut self) -> Pin<&mut <Ptr as Deref>::Target>

### Description
Gets a mutable reference to the pinned value this Pin<Ptr> points to. This method is useful when doing multiple calls to functions that consume the pinning pointer.
```

--------------------------------

### Compiling with task configuration

Source: https://docs.rs/juncture/0.3.1/juncture/fn.compile_entrypoint.html

Shows how to use compile_entrypoint_with_config to apply retry policies and timeouts to a workflow.

```rust
use juncture_core::func::compile_entrypoint_with_config;
use juncture_core::config::TaskConfig;
use juncture_core::graph::{RetryPolicy, NodeMetadata};
use std::time::Duration;

let retry_policy = RetryPolicy::max_attempts(3);
let task_config = TaskConfig {
    retry_policy: Some(retry_policy.clone()),
    cache_policy: None,
    timeout: Some(Duration::from_secs(30)),
    name: Some("my_workflow".to_string()),
};

let graph = compile_entrypoint_with_config(
    my_workflow,
    &task_config,
    Some(Arc::new(MemorySaver::new()))
)?;
```

--------------------------------

### Get Current State

Source: https://docs.rs/juncture/0.3.1/juncture/client/struct.GraphClient.html?search=

Retrieves the current state snapshot for a specific thread.

```rust
pub async fn get_state<T>( &self, thread_id: &str, ) -> Result<StateSnapshot<T>, ClientError>
where T: for<'de> Deserialize<'de>,
```

--------------------------------

### Initialize and use a TopicChannel

Source: https://docs.rs/juncture/0.3.1/juncture/prelude/state/channel/struct.TopicChannel.html

Demonstrates creating a TopicChannel, publishing messages via update, retrieving them, and clearing the channel state.

```rust
use juncture_core::state::channel::{Channel, TopicChannel};

let mut channel: TopicChannel<String> = TopicChannel::new();

// Publish messages. `TopicChannel<T>` implements `Channel<Vec<T>>`, so
// `update` takes `Vec<Vec<T>>` (one batch per publisher).
channel.update(vec![vec!["hello".to_string()]]);
channel.update(vec![vec!["world".to_string()]]);

// Get all accumulated messages
let messages = channel.get();
assert_eq!(messages.len(), 2);
assert_eq!(messages[0], "hello");
assert_eq!(messages[1], "world");

// Consume (clear) for the next superstep
drop(messages);
assert!(channel.consume());
assert!(channel.get().is_empty());
```

--------------------------------

### Synchronous and Asynchronous Invocation

Source: https://docs.rs/juncture/0.3.1/juncture/prelude/struct.CompiledGraph.html?search=u32+-%3E+bool

Examples of invoking the compiled graph synchronously and asynchronously.

```rust
let output = compiled.invoke(initial_state, &config)?;
let final_state = output.value;
```

```rust
let output = compiled.invoke_async(initial_state, &config).await?;
let final_state = output.value;
```
Tokens:
Raw