Weavegraph

https://docs.rs/weavegraph/0.3.0
Admin
Weavegraph is a graph-driven workflow framework for Rust that enables concurrent, stateful execution...
Tokens:343,322
Snippets:2,749
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Building a Simple Workflow with GraphBuilder

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/graphs/mod.rs.html

Illustrates the quick start process for building a basic workflow graph using GraphBuilder. This example shows how to add a custom node and connect it between the virtual Start and End nodes.

```rust
use weavegraph::graphs::GraphBuilder;
use weavegraph::types::NodeKind;
use weavegraph::node::{Node, NodeContext, NodePartial, NodeError};
use weavegraph::state::StateSnapshot;
use async_trait::async_trait;

// Define a simple node
struct MyNode;

#[async_trait]
impl Node for MyNode {
    async fn run(&self, _: StateSnapshot, _: NodeContext) -> Result<NodePartial, NodeError> {
        Ok(NodePartial::default())
    }
}

// Build a simple workflow (virtual Start/End):
// Start (virtual) -> process -> End (virtual)
let app = GraphBuilder::new()
    .add_node(NodeKind::Custom("process".into()), MyNode)
    .add_edge(NodeKind::Start, NodeKind::Custom("process".into()))
    .add_edge(NodeKind::Custom("process".into()), NodeKind::End)
    .compile();

```

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

### Rust: Example Usage of Checkpointer Helpers

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/runtimes/checkpointer_postgres_helpers.rs.html

Illustrates how to use the provided JSON serialization and deserialization helpers within the PostgreSQL checkpointer. Includes examples for serialization, deserialization, value deserialization, and field validation.

```rust
// Serialization
let json_str = serialize_json(&data, "user_data")?;

// Deserialization
let data: MyType = deserialize_json(&json_str, "user_data")?;

// Value deserialization
let data: MyType = deserialize_json_value(json_value, "user_data")?;

// Field validation
let required_field = require_json_field(optional_field, "state_json")?;
```

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

### JsonLinesSink Usage Examples

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/event_bus/sink.rs.html

Examples showing how to initialize JsonLinesSink for stdout, file output, or pretty-printing.

```rust
use weavegraph::event_bus::{EventBus, JsonLinesSink};

let sink = JsonLinesSink::to_stdout();
let bus = EventBus::with_sinks(vec![Box::new(sink)]);
// Events will be written as JSON lines to stdout
```

```rust
use weavegraph::event_bus::{EventBus, JsonLinesSink};

let sink = JsonLinesSink::to_file("events.jsonl").unwrap();
let bus = EventBus::with_sinks(vec![Box::new(sink)]);
// Events will be written to events.jsonl
```

```rust
use weavegraph::event_bus::JsonLinesSink;
use std::io;

let sink = JsonLinesSink::with_pretty_print(Box::new(io::stdout()));
// Events will be pretty-printed (not valid JSONL, but human-readable)
```

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

### SystemClock Usage Example

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/utils/clock.rs.html

Demonstrates how to use `SystemClock` to get the current Unix timestamp and `DateTime<Utc>`.

```rust
use weavegraph::utils::clock::{Clock, SystemClock};

let clock = SystemClock;
let timestamp = clock.now();
let datetime = clock.now_datetime();
println!("Current timestamp: {}", timestamp);
```

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

### NodePartial Examples

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/node/struct.NodePartial.html

Examples demonstrating the usage of NodePartial for different scenarios.

```APIDOC
## §Examples
```rust
use weavegraph::node::NodePartial;
use weavegraph::message::{Message, Role};
use weavegraph::channels::errors::{ErrorEvent, WeaveError};
use serde_json::json;
use weavegraph::utils::collections::new_extra_map;

// Simple message-only response
let partial = NodePartial::new()
    .with_messages(vec![Message::with_role(Role::Assistant, "Done")]);

// Rich response with metadata
let mut extra = new_extra_map();
extra.insert("status".to_string(), json!("success"));
extra.insert("duration_ms".to_string(), json!(150));
let partial = NodePartial::new()
    .with_messages(vec![Message::with_role(
        Role::Assistant,
        "Processing complete",
    )])
    .with_extra(extra);

// Response with warnings
let errors = vec![ErrorEvent {
    error: WeaveError {
        message: "Low confidence result".to_string(),
        ..Default::default()
    },
    ..Default::default()
}];
let partial = NodePartial::new()
    .with_messages(vec![Message::with_role(
        Role::Assistant,
        "Result with warnings",
    )])
    .with_errors(errors);
```
```

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

### Example: Default Random ID Generation

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/utils/id_generator.rs.html

Demonstrates creating an ID generator with default settings and generating a run ID, asserting it starts with the expected prefix.

```rust
use weavegraph::utils::id_generator::{IdGenerator, IdConfig};

// Default random ID generation
let generator = IdGenerator::new();
let id = generator.generate_run_id();
assert!(id.starts_with("run-"));
```

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

### Example: Route by Extra Data (Fan Out)

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/graphs/type.EdgePredicate.html

Shows how to route based on the presence of 'error' in the extra data of the state snapshot. This example fans out to multiple nodes and can optionally lead to an end node.

```rust
// Route based on extra data - fan out to multiple nodes and optionally End
let route_by_error: EdgePredicate = Arc::new(|snapshot| {
    if snapshot.extra.get("error").is_some() {
        vec![
            NodeKind::Custom("error_handler".into()).as_target(),
            NodeKind::Custom("logger".into()).as_target(),
        ]
    } else {
        vec![NodeKind::end_target()]
    }
});
```

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

### Example: Initialize VersionedState with User Message

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/state.rs.html

Demonstrates creating a VersionedState with an initial user message and verifying its contents.

```rust
use weavegraph::state::VersionedState;

let state = VersionedState::new_with_user_message("Analyze this data");
let snapshot = state.snapshot();

assert_eq!(snapshot.messages.len(), 1);
assert_eq!(snapshot.messages[0].role, weavegraph::message::Role::User);
assert_eq!(snapshot.messages[0].content, "Analyze this data");
assert_eq!(snapshot.messages_version, 1);
assert!(snapshot.extra.is_empty());
```

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

### MockClock Initialization and Advancement

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/utils/clock.rs.html

Shows how to create a `MockClock` starting at a specific time and advance it by a duration.

```rust
use weavegraph::utils::clock::{Clock, MockClock};
use std::time::Duration;

let mut clock = MockClock::new(1000);
assert_eq!(clock.now(), 1000);

clock.advance(Duration::from_secs(30));
assert_eq!(clock.now(), 1030);

// Test timeout behavior
assert!(clock.has_elapsed(1000, Duration::from_secs(25)));
```

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

### Petgraph Integration Example

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/graphs/builder.rs.html

Example demonstrating the usage of petgraph integration for graph analysis.

```rust
use weavegraph::graphs::GraphBuilder;
use petgraph::algo::is_cyclic_directed;
```

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

### Checkpointer Usage Example

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/runtimes/checkpointer/trait.Checkpointer.html

Demonstrates basic usage of the InMemoryCheckpointer to save, load, and list workflow sessions.

```rust
use weavegraph::runtimes::{Checkpointer, Checkpoint, InMemoryCheckpointer};
use weavegraph::state::VersionedState;

let checkpointer = InMemoryCheckpointer::new();

// Save a checkpoint
let state = VersionedState::new_with_user_message("Hello");
// ... create checkpoint from session state
checkpointer.save(checkpoint).await?;

// Load the latest checkpoint
if let Some(checkpoint) = checkpointer.load_latest("session_id").await? {
    // Resume execution from checkpoint
    println!("Resuming from step {}", checkpoint.step);
}

// List all sessions
let sessions = checkpointer.list_sessions().await?;
println!("Found {} sessions", sessions.len());
```

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

### Construct NodePartial instances

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/node/struct.NodePartial.html

Examples demonstrating how to create NodePartial instances with messages, metadata, or error events.

```rust
use weavegraph::node::NodePartial;
use weavegraph::message::{Message, Role};
use weavegraph::channels::errors::{ErrorEvent, WeaveError};
use serde_json::json;
use weavegraph::utils::collections::new_extra_map;

// Simple message-only response
let partial = NodePartial::new()
    .with_messages(vec![Message::with_role(Role::Assistant, "Done")]);

// Rich response with metadata
let mut extra = new_extra_map();
extra.insert("status".to_string(), json!("success"));
extra.insert("duration_ms".to_string(), json!(150));
let partial = NodePartial::new()
    .with_messages(vec![Message::with_role(
        Role::Assistant,
        "Processing complete",
    )])
    .with_extra(extra);

// Response with warnings
let errors = vec![ErrorEvent {
    error: WeaveError {
        message: "Low confidence result".to_string(),
        ..Default::default()
    },
    ..Default::default()
}];
let partial = NodePartial::new()
    .with_messages(vec![Message::with_role(
        Role::Assistant,
        "Result with warnings",
    )])
    .with_errors(errors);
```

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

### PlainFormatter Constructors

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/telemetry/struct.PlainFormatter.html

Examples of how to create new PlainFormatter instances using different modes.

```APIDOC
## §Examples
```
use weavegraph::telemetry::{PlainFormatter, FormatterMode};

// Auto-detect TTY
let formatter = PlainFormatter::new();

// Force colored output
let formatter = PlainFormatter::with_mode(FormatterMode::Colored);

// Force plain output (no colors)
let formatter = PlainFormatter::with_mode(FormatterMode::Plain);
```
```

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

### GraphBuilder Example

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/graphs/struct.EdgesIter.html

Demonstrates how to use GraphBuilder to add nodes and edges, and then collect the edges using the edges() iterator.

```rust
use weavegraph::graphs::GraphBuilder;
use weavegraph::types::NodeKind;


let builder = GraphBuilder::new()
    .add_node(NodeKind::Custom("A".into()), MyNode)
    .add_edge(NodeKind::Start, NodeKind::Custom("A".into()))
    .add_edge(NodeKind::Custom("A".into()), NodeKind::End);

let edges: Vec<_> = builder.edges().collect();
assert_eq!(edges.len(), 2);
```

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

### Retrieve Graph Edges

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/graphs/builder.rs.html

Example demonstrating how to build a graph and count its edges using the GraphBuilder.

```rust
use weavegraph::graphs::GraphBuilder;
use weavegraph::types::NodeKind;

# struct MyNode;
# #[async_trait::async_trait]
# impl weavegraph::node::Node for MyNode {
#     async fn run(&self, _: weavegraph::state::StateSnapshot, _: weavegraph::node::NodeContext) -> Result<weavegraph::node::NodePartial, weavegraph::node::NodeError> {
#         Ok(weavegraph::node::NodePartial::default())
#     }
# }

let builder = GraphBuilder::new()
    .add_node(NodeKind::Custom("A".into()), MyNode)
    .add_edge(NodeKind::Start, NodeKind::Custom("A".into()))
    .add_edge(NodeKind::Custom("A".into()), NodeKind::End);

let edge_count = builder.edges().count();
assert_eq!(edge_count, 2);
```

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

### Example: Construct VersionedState using Builder

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/state.rs.html

Demonstrates using the builder pattern to create a VersionedState with multiple messages and extra data.

```rust
use weavegraph::state::VersionedState;
use weavegraph::channels::Channel;
use serde_json::json;

let state = VersionedState::builder()
    .with_user_message("Hello, assistant!")
    .with_assistant_message("Hello! How can I help you?")
    .with_extra("session_id", json!("session_123"))
    .with_extra("priority", json!("high"))
    .build();

let snapshot = state.snapshot();
assert_eq!(snapshot.messages.len(), 2);
assert_eq!(snapshot.extra.len(), 2);
```

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

### Getting Metadata with `and_then`

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/node/type.NodeResult.html

Demonstrates using `and_then` to chain operations that might fail, such as getting file metadata. This example shows how to handle potential errors like a non-existent path.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

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

### Basic AppRunner Usage with Defaults

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/runtimes/runner/struct.AppRunnerBuilder.html

Demonstrates the simplest way to build an AppRunner using default settings. Requires `app` and a checkpointer type.

```rust
use weavegraph::runtimes::{AppRunner, CheckpointerType};

let runner = AppRunner::builder()
    .app(app)
    .checkpointer(CheckpointerType::InMemory)
    .build()
    .await;
```

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

### Get Canonical Target Strings

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/types/enum.NodeKind.html

Convenience methods to retrieve the canonical target strings for Start and End endpoints.

```rust
assert_eq!(NodeKind::start_target(), "Start");
```

```rust
assert_eq!(NodeKind::end_target(), "End");
```

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

### Workflow Runtime Usage Example

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/runtimes/mod.rs.html

Demonstrates how to initialize and use the AppRunner to create a session and run a workflow to completion. Requires `AppRunner`, `CheckpointerType`, `VersionedState`, and `App` types.

```rust
use weavegraph::runtimes::{AppRunner, CheckpointerType};
use weavegraph::state::VersionedState;
# use weavegraph::app::App;
# async fn example(app: App) -> Result<(), Box<dyn std::error::Error>> {

let mut runner = AppRunner::builder()
    .app(app)
    .checkpointer(CheckpointerType::InMemory)
    .build()
    .await;
let initial_state = VersionedState::new_with_user_message("Hello");

// Create session and run to completion
runner.create_session("session_1".to_string(), initial_state).await?;
let final_state = runner.run_until_complete("session_1").await?;
# Ok(())
# }
```

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

### Get Node Count

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/graphs/struct.GraphBuilder.html

Returns the number of registered nodes in the graph. Does not include virtual `Start` and `End` nodes.

```APIDOC
## GET /websites/rs_weavegraph_0_3_0/node_count

### Description
Returns the number of registered nodes in the graph. Does not include virtual `Start` and `End` nodes.

### Method
GET

### Endpoint
/websites/rs_weavegraph_0_3_0/node_count

### Response
#### Success Response (200)
- **usize** (usize) - The number of nodes in the graph.

#### Response Example
```json
{
  "count": 2
}
```
```

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

### Example: Initialize VersionedState with Message History

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/state.rs.html

Shows how to create a VersionedState using an existing list of messages, useful for chat history.

```rust
use weavegraph::state::VersionedState;
use weavegraph::message::{Message, Role};

let messages = vec![
    Message::with_role(Role::User, "Explain error handling in Rust"),
    Message::with_role(
        Role::Assistant,
        "Use Result and the ? operator to propagate errors cleanly.",
    ),
];
let state = VersionedState::new_with_messages(messages);
let snapshot = state.snapshot();

assert_eq!(snapshot.messages.len(), 2);
assert_eq!(snapshot.messages_version, 1);
assert!(snapshot.extra.is_empty());
```

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

### Get canonical target strings

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/types.rs.html

Convenience methods to retrieve the standard target strings for Start and End nodes.

```rust
# use weavegraph::types::NodeKind;
assert_eq!(NodeKind::start_target(), "Start");
```

```rust
# use weavegraph::types::NodeKind;
assert_eq!(NodeKind::end_target(), "End");
```

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

### Get Nodes Iterator

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/graphs/struct.GraphBuilder.html

Returns an iterator over all registered nodes in the graph. This iterates over custom nodes only; virtual `Start` and `End` nodes are not included.

```APIDOC
## GET /websites/rs_weavegraph_0_3_0/nodes

### Description
Returns an iterator over all registered nodes in the graph. This iterates over custom nodes only; virtual `Start` and `End` nodes are not included as they are not stored in the registry.

### Method
GET

### Endpoint
/websites/rs_weavegraph_0_3_0/nodes

### Response
#### Success Response (200)
- **NodesIter** (NodesIter<'_>) - An iterator over the graph's nodes.

#### Response Example
```json
[
  "NodeA",
  "NodeB"
]
```
```

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

### Example of Building and Invoking a Weavegraph App

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/app.rs.html

Demonstrates how to build a simple graph with nodes and edges, compile it into an App, and then invoke it with initial state.

```rust
use weavegraph::graphs::GraphBuilder;
use weavegraph::runtimes::CheckpointerType;
use weavegraph::state::VersionedState;
use weavegraph::types::NodeKind;
use weavegraph::node::{Node, NodeContext, NodeError, NodePartial};
use async_trait::async_trait;

# struct MyNode;
# #[async_trait]
# impl Node for MyNode {
#     async fn run(&self, _: weavegraph::state::StateSnapshot, _: NodeContext) -> Result<NodePartial, NodeError> {
#         Ok(NodePartial::default())
#     }
# }
# 
# async fn example() -> Result<(), Box<dyn std::error::Error>> {
let app = GraphBuilder::new()
    .add_node(NodeKind::Custom("process".into()), MyNode)
    .add_edge(NodeKind::Start, NodeKind::Custom("process".into()))
    .add_edge(NodeKind::Custom("process".into()), NodeKind::End)
    .compile()?;

let initial_state = VersionedState::new_with_user_message("Hello");
let final_state = app.invoke(initial_state).await?;
# Ok(())
# }
```

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

### Get Edges Iterator

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/graphs/struct.GraphBuilder.html

Returns an iterator over all edges in the graph as (source, target) pairs. Includes edges from/to virtual `Start` and `End` nodes.

```APIDOC
## GET /websites/rs_weavegraph_0_3_0/edges

### Description
Returns an iterator over all edges in the graph as (source, target) pairs. Includes edges from/to virtual `Start` and `End` nodes. The iteration order is not deterministic due to hash map iteration; use `topological_sort` for ordered traversal.

### Method
GET

### Endpoint
/websites/rs_weavegraph_0_3_0/edges

### Response
#### Success Response (200)
- **EdgesIter** (EdgesIter<'_>) - An iterator over the graph's edges.

#### Response Example
```json
[
  ["Start", "NodeA"],
  ["NodeA", "End"]
]
```
```

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

### App Struct Overview

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/app/struct.App.html

Provides details about the App struct, its purpose, and an example of its usage in building and invoking a graph.

```APIDOC
## Struct App

### Summary
```
pub struct App { /* private fields */ }
```

### Description
Orchestrates graph execution and applies reducers at barriers.
`App` is the central coordination point for workflow execution, managing:
  * Node graph topology (nodes, edges, conditional routing)
  * State reduction through configurable reducers
  * Runtime configuration and checkpointing

## §Examples
```rust
use weavegraph::graphs::GraphBuilder;
use weavegraph::runtimes::CheckpointerType;
use weavegraph::state::VersionedState;
use weavegraph::types::NodeKind;
use weavegraph::node::{Node, NodeContext, NodeError, NodePartial};
use async_trait::async_trait;

let app = GraphBuilder::new()
    .add_node(NodeKind::Custom("process".into()), MyNode)
    .add_edge(NodeKind::Start, NodeKind::Custom("process".into()))
    .add_edge(NodeKind::Custom("process".into()), NodeKind::End)
    .compile()?;

let initial_state = VersionedState::new_with_user_message("Hello");
let final_state = app.invoke(initial_state).await?;
```
```

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

### Perform Topological Sort

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/graphs/builder.rs.html

Example showing how to obtain a topologically sorted list of nodes. This method assumes the graph is acyclic.

```rust
use weavegraph::graphs::GraphBuilder;
use weavegraph::types::NodeKind;

# struct MyNode;
# #[async_trait::async_trait]
# impl weavegraph::node::Node for MyNode {
#     async fn run(&self, _: weavegraph::state::StateSnapshot, _: weavegraph::node::NodeContext) -> Result<weavegraph::node::NodePartial, weavegraph::node::NodeError> {
#         Ok(weavegraph::node::NodePartial::default())
#     }
# }

let builder = GraphBuilder::new()
    .add_node(NodeKind::Custom("A".into()), MyNode)
    .add_node(NodeKind::Custom("B".into()), MyNode)
    .add_edge(NodeKind::Start, NodeKind::Custom("A".into()))
    .add_edge(NodeKind::Custom("A".into()), NodeKind::Custom("B".into()))
    .add_edge(NodeKind::Custom("B".into()), NodeKind::End);

let sorted = builder.topological_sort();
assert_eq!(sorted[0], NodeKind::Start);
assert_eq!(sorted[sorted.len() - 1], NodeKind::End);

// A comes before B due to edge A -> B
let a_pos = sorted.iter().position(|n| n == &NodeKind::Custom("A".into())).unwrap();
let b_pos = sorted.iter().position(|n| n == &NodeKind::Custom("B".into())).unwrap();
assert!(a_pos < b_pos);
```

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

### GraphBuilder::with_reducer_registry

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/graphs/builder.rs.html

Replaces the entire reducer registry with a custom one. This method provides complete control over reducer configuration, useful for complex setups or starting with an empty registry.

```APIDOC
## PUT /api/users/{id}

### Description
Replaces the entire reducer registry with a custom one.

### Method
PUT

### Endpoint
/api/users/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - The ID of the user to update.

#### Request Body
- **registry** (ReducerRegistry) - Required - The reducer registry to use for the user.

### Response
#### Success Response (200)
- **message** (string) - Indicates successful update of the reducer registry.

#### Response Example
{
  "message": "Reducer registry updated successfully"
}
```

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

### Initialize and Snapshot VersionedState

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/state.rs.html

Demonstrates creating a state container, adding metadata, and capturing an immutable snapshot.

```rust
use weavegraph::state::VersionedState;
use weavegraph::channels::Channel;
use serde_json::json;

// Create initial state with user message
let mut state = VersionedState::new_with_user_message("Hello, world!");

// Add some metadata
state.extra.get_mut().insert("user_id".to_string(), json!("user123"));

// Take snapshot for processing
let snapshot = state.snapshot();
assert_eq!(snapshot.messages.len(), 1);
assert_eq!(snapshot.extra.get("user_id"), Some(&json!("user123")));
```

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

### Topological Sort of a Graph

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/graphs/struct.GraphBuilder.html

Demonstrates building a graph with nodes and edges, then performing a topological sort to get a linear ordering of nodes. Asserts the start and end nodes are in their expected positions and that node A comes before node B.

```rust
use weavegraph::graphs::GraphBuilder;
use weavegraph::types::NodeKind;


let builder = GraphBuilder::new()
    .add_node(NodeKind::Custom("A".into()), MyNode)
    .add_node(NodeKind::Custom("B".into()), MyNode)
    .add_edge(NodeKind::Start, NodeKind::Custom("A".into()))
    .add_edge(NodeKind::Custom("A".into()), NodeKind::Custom("B".into()))
    .add_edge(NodeKind::Custom("B".into()), NodeKind::End);

let sorted = builder.topological_sort();
assert_eq!(sorted[0], NodeKind::Start);
assert_eq!(sorted[sorted.len() - 1], NodeKind::End);

// A comes before B due to edge A -> B
let a_pos = sorted.iter().position(|n| n == &NodeKind::Custom("A".into())).unwrap();
let b_pos = sorted.iter().position(|n| n == &NodeKind::Custom("B".into())).unwrap();
assert!(a_pos < b_pos);
```

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

### Initialize and Use SchedulerState

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/schedulers/scheduler/struct.SchedulerState.html

Demonstrates initializing SchedulerState, creating a Scheduler, simulating state changes, recording seen versions, and checking if a node should run. Ensure necessary imports are included.

```rust
use weavegraph::channels::Channel;
use weavegraph::schedulers::{Scheduler, SchedulerState};
use weavegraph::state::VersionedState;

let mut sched_state = SchedulerState::default();
let scheduler = Scheduler::new(2);

// Simulate a snapshot with version changes
let mut state = VersionedState::builder().build();
state.messages.set_version(3);
let snapshot = state.snapshot();

// Record that a node has seen these versions
scheduler.record_seen(&mut sched_state, "node_a", &snapshot);

// Later checks will use this information for gating
assert!(!scheduler.should_run(&sched_state, "node_a", &snapshot));
```

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

### Set Start Listener Option

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/runtimes/runner.rs.html

Controls whether the event listener starts immediately upon runner creation. Defaults to `true`. Set to `false` if further EventBus configuration is needed before starting.

```rust
/// Set whether to start the event listener immediately.
///
/// Defaults to `true`. Set to `false` if you need to configure
/// the EventBus further before starting.
#[must_use]
pub fn start_listener(mut self, start: bool) -> Self {
    self.start_listener = start;
    self
}
```

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

### JsonLinesSink Custom Writer Example

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/event_bus/sink.rs.html

Example of creating a JsonLinesSink with a custom writer.

```rust
use weavegraph::event_bus::JsonLinesSink;
```

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

### Initialize VersionedState and Add Messages

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/state/struct.VersionedState.html

Demonstrates creating a new state with an initial message and appending assistant messages.

```rust
use weavegraph::state::VersionedState;

let mut state = VersionedState::new_with_user_message("Initial message");
state.add_message(
    weavegraph::message::Role::Assistant.as_str(),
    "I understand your request.",
);

let snapshot = state.snapshot();
assert_eq!(snapshot.messages.len(), 2);
assert_eq!(snapshot.messages[1].role, weavegraph::message::Role::Assistant);
```

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

### AppRunner Builder Basic Usage

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/runtimes/runner.rs.html

Demonstrates basic usage of the AppRunner builder with default settings and an in-memory checkpointer. Requires an App instance.

```rust
use weavegraph::app::App;
use weavegraph::runtimes::{AppRunner, CheckpointerType};

async fn example(app: App) -> Result<(), Box<dyn std::error::Error>> {

let runner = AppRunner::builder()
    .app(app)
    .checkpointer(CheckpointerType::InMemory)
    .build()
    .await;
Ok(())
}
```

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

### JsonLinesSink Format Example

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/event_bus/sink.rs.html

Example of the JSON Lines format used by the JsonLinesSink.

```json
{"type":"node","scope":"routing","message":"Processing","timestamp":"2025-11-03T12:34:56Z","metadata":{"node_id":"router","step":5}}
{"type":"diagnostic","scope":"system","message":"Ready","timestamp":"2025-11-03T12:34:57Z","metadata":{}}
```

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

### IdGenerator Initialization

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/utils/id_generator/struct.IdGenerator.html

Demonstrates how to create new instances of the IdGenerator, either with default settings or custom configurations.

```APIDOC
## IdGenerator Initialization

### Description
Provides methods to create `IdGenerator` instances.

### Methods

#### `new()`
Create a new ID generator with default configuration.
Uses random UUID generation without prefixes or deterministic behavior.

##### Returns
A new `IdGenerator` instance with default settings.

#### `with_config(config: IdConfig)`
Create an ID generator with custom configuration.

##### Parameters
- `config` (IdConfig) - Configuration specifying ID generation behavior.

##### Returns
A new `IdGenerator` instance with the specified configuration.

### Examples

```rust
use weavegraph::utils::id_generator::{IdGenerator, IdConfig};

// Default random ID generation
let generator = IdGenerator::new();
let id = generator.generate_run_id();
assert!(id.starts_with("run-"));

// Deterministic generation for testing
let config = IdConfig {
    seed: Some(12345),
    prefix: Some("test".into()),
    ..Default::default()
};
let det_generator = IdGenerator::with_config(config);
let det_id = det_generator.generate_id();

// Custom configuration example
let custom_config = IdConfig {
    seed: Some(42),
    prefix: Some("weavegraph".into()),
    include_timestamp: true,
    use_counter: false,
};
let custom_generator = IdGenerator::with_config(custom_config);
```
```

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

### Detect unreachable nodes

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/graphs/compilation.rs.html

Performs a breadth-first search (BFS) starting from the Start node to identify nodes that cannot be reached via unconditional edges.

```rust
fn detect_unreachable_nodes(&self) -> Vec<NodeKind> {
        use std::collections::VecDeque;

        let mut reachable: FxHashMap<NodeKind, bool> = FxHashMap::default();
        let mut queue: VecDeque<NodeKind> = VecDeque::new();

        // Start BFS from Start node
        queue.push_back(NodeKind::Start);
        reachable.insert(NodeKind::Start, true);

        while let Some(node) = queue.pop_front() {
            if let Some(neighbors) = self.edges_ref().get(&node) {
                for neighbor in neighbors {
                    if !reachable.contains_key(neighbor) {
                        reachable.insert(neighbor.clone(), true);
                        queue.push_back(neighbor.clone());
                    }
                }
            }
        }

        // Find registered Custom nodes that are not reachable
        let mut unreachable: Vec<NodeKind> = self
            .nodes_ref()
            .keys()
            .filter(|node| !reachable.contains_key(node))
            .cloned()
            .collect();

        unreachable.sort_by_key(|a| a.to_string());
        unreachable
    }
```

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

### Initialize ReducerRegistry with a reducer

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/reducers/struct.ReducerRegistry.html

Demonstrates the builder-style pattern to create a registry and register a reducer in a single fluent chain.

```rust
use std::sync::Arc;
use weavegraph::reducers::{ReducerRegistry, AddMessages};
use weavegraph::types::ChannelType;

let registry = ReducerRegistry::new()
    .with_reducer(ChannelType::Message, Arc::new(AddMessages));
```

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

### Example: Deterministic Generation for Testing

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/utils/id_generator.rs.html

Shows how to configure an ID generator with a seed and prefix for deterministic ID generation, useful for testing and reproducibility.

```rust
let config = IdConfig {
    seed: Some(12345),
    prefix: Some("test".into()),
    ..Default::default()
};
let det_generator = IdGenerator::with_config(config);
let det_id = det_generator.generate_id();
```

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

### Get references to Result values

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/node/type.NodeResult.html

Use `as_ref` to get a `Result` containing references to the contained values, without consuming the original `Result`. This is useful for inspecting values without taking ownership.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

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

### Initialize Postgres Checkpointer

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/runtimes/runner.rs.html

Connects to a Postgres database using environment variables for configuration, defaulting to a local instance if not specified.

```rust
let db_url = std::env::var("WEAVEGRAPH_POSTGRES_URL")
                    .ok()
                    .or_else(|| std::env::var("DATABASE_URL").ok())
                    .unwrap_or_else(|| "postgresql://localhost/weavegraph".to_string());
                match crate::runtimes::PostgresCheckpointer::connect(&db_url).await {
                    Ok(cp) => Some(Arc::new(cp) as Arc<dyn Checkpointer>),
                    Err(e) => {
                        tracing::error!(
                            url = %db_url,
                            error = %e,
                            "PostgresCheckpointer initialization failed"
                        );
                        None
                    }
                }
```

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

### Get HubEmitter

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/event_bus/hub/struct.EventHub.html

Returns a HubEmitter for publishing events.

```rust
pub fn emitter(self: &Arc<Self>) -> HubEmitter
```

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

### Create and Use Scheduler

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/schedulers/scheduler/index.html

Demonstrates creating a scheduler with a concurrency limit and checking if a node should run based on version changes in the state. Ensure the necessary imports are present.

```rust
use weavegraph::channels::Channel;
use weavegraph::schedulers::{Scheduler, SchedulerState};
use weavegraph::state::VersionedState;

// Create scheduler with concurrency limit
let scheduler = Scheduler::new(4);
let mut sched_state = SchedulerState::default();

// Check if a node should run based on version changes
let mut state = VersionedState::builder().build();
state.messages.set_version(2);
let snapshot = state.snapshot();

let should_run = scheduler.should_run(&sched_state, "node_id", &snapshot);
if should_run {
    println!("Node should run - state has changed");
}
```

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

### Arc::new

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/graphs/type.EdgePredicate.html

Constructs a new Arc instance.

```APIDOC
## fn new(data: T) -> Arc<T>

### Description
Constructs a new Arc<T>.

### Parameters
#### Request Body
- **data** (T) - Required - The value to be wrapped in an Arc.
```

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

### Get Sinks

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/runtimes/runtime_config/struct.EventBusConfig.html

Returns a slice of the configured sinks for the EventBusConfig.

```rust
pub fn sinks(&self) -> &[SinkConfig]
```

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

### Get Buffer Capacity

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/runtimes/runtime_config/struct.EventBusConfig.html

Returns the buffer capacity of the EventBusConfig.

```rust
pub fn buffer_capacity(&self) -> usize
```

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

### Connect to PostgreSQL database

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/runtimes/checkpointer_postgres.rs.html

Initializes a connection to the database and optionally runs migrations if the feature is enabled.

```rust
pub async fn connect(database_url: &str) -> std::result::Result<Self, CheckpointerError> {
        let pool = PgPool::connect(database_url)
            .await
            .map_err(|e| CheckpointerError::Backend {
                message: format!("connect error: {e}"),
            })?;
        // Run embedded migrations only if the feature is enabled (idempotent).
        #[cfg(feature = "postgres-migrations")]
        {
            if let Err(e) = sqlx::migrate!("./migrations/postgres").run(&pool).await {
                return Err(CheckpointerError::Backend {
                    message: format!("migration failure: {e}"),
                });
            }
        }
        #[cfg(not(feature = "postgres-migrations"))]
        {
            // Feature disabled: assume external migration orchestration already applied schema.
        }
        Ok(Self {
            pool: Arc::new(pool),
        })
    }
```

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

### Get timestamp from LLMStreamingEvent

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/event_bus/event/struct.LLMStreamingEvent.html

Returns the timestamp when the event occurred.

```rust
pub fn timestamp(&self) -> DateTime<Utc>
```

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

### Compile GraphBuilder into App

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/graphs/compilation.rs.html

Examples demonstrating how to compile a graph, including basic error propagation and explicit pattern matching for specific validation errors.

```rust
use weavegraph::graphs::GraphBuilder;
use weavegraph::types::NodeKind;

# struct MyNode;
# #[async_trait::async_trait]
# impl weavegraph::node::Node for MyNode {
#     async fn run(&self, _: weavegraph::state::StateSnapshot, _: weavegraph::node::NodeContext) -> Result<weavegraph::node::NodePartial, weavegraph::node::NodeError> {
#         Ok(weavegraph::node::NodePartial::default())
#     }
# }

let app = GraphBuilder::new()
    .add_node(NodeKind::Custom("process".into()), MyNode)
    .add_edge(NodeKind::Start, NodeKind::Custom("process".into()))
    .add_edge(NodeKind::Custom("process".into()), NodeKind::End)
    .compile()?;
# Ok::<_, weavegraph::graphs::GraphCompileError>(())
```

```rust
use weavegraph::graphs::{GraphBuilder, GraphCompileError};
use weavegraph::types::NodeKind;

let result = GraphBuilder::new()
    .add_edge(NodeKind::Start, NodeKind::Custom("A".into()))
    .compile();

match result {
    Ok(_app) => {}
    Err(GraphCompileError::MissingEntry) => {
        eprintln!("graph has no entry edge from Start");
    }
    Err(GraphCompileError::UnknownNode(nk)) => {
        eprintln!("unknown node referenced: {nk}");
    }
    Err(e) => {
        eprintln!("graph validation failed: {e}");
    }
}
```

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

### Get metadata from LLMStreamingEvent

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/event_bus/event/struct.LLMStreamingEvent.html

Returns the metadata associated with the event.

```rust
pub fn metadata(&self) -> &FxHashMap<String, Value>
```

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

### Get scope from LLMStreamingEvent

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/event_bus/event/struct.LLMStreamingEvent.html

Returns the scope associated with the event.

```rust
pub fn scope(&self) -> &LLMStreamingEventScope
```

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

### POST /AppRunner/with_options_and_bus

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/runtimes/runner/struct.AppRunner.html

Initializes an AppRunner with a custom EventBus, enabling advanced event handling and streaming capabilities for production workflows.

```APIDOC
## POST /AppRunner/with_options_and_bus

### Description
Creates an AppRunner instance with a custom EventBus. This is the preferred method for production applications requiring real-time event streaming to external sinks like web clients or logging systems.

### Parameters
#### Request Body
- **app** (App) - Required - The compiled workflow graph.
- **checkpointer_type** (CheckpointerType) - Required - Persistence strategy (InMemory or SQLite).
- **autosave** (bool) - Required - Whether to automatically save checkpoints after each step.
- **event_bus** (EventBus) - Required - Custom EventBus instance with desired sinks.
- **start_listener** (bool) - Required - Whether to start the EventBus listener immediately.

### Returns
- **AppRunner** - A configured AppRunner instance ready for workflow execution.
```

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

### Get EventHub metrics

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/event_bus/hub/struct.EventHub.html

Retrieves metrics associated with the EventHub.

```rust
pub fn metrics(&self) -> EventHubMetrics
```

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

### GET /sessions

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/runtimes/checkpointer.rs.html

Lists all currently active session identifiers.

```APIDOC
## GET /sessions

### Description
Returns a list of all session identifiers currently tracked in the system.

### Method
GET

### Endpoint
/sessions

### Response
#### Success Response (200)
- **sessions** (Array<string>) - A list of active session IDs.
```

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

### Scheduler Initialization

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/schedulers/scheduler.rs.html

Demonstrates how to create a new Scheduler instance with a specified concurrency limit. If the limit is set to 0, it defaults to 1.

```APIDOC
## POST /scheduler/new

### Description
Creates a new scheduler with the specified concurrency limit.
If `concurrency_limit` is 0, it will be set to 1 to ensure at least one concurrent task can run.

### Method
POST

### Endpoint
`/scheduler/new`

### Parameters
#### Query Parameters
- **concurrency_limit** (usize) - Required - Maximum number of concurrent node executions

### Request Example
```json
{
  "concurrency_limit": 5
}
```

### Response
#### Success Response (200)
- **scheduler_id** (string) - Unique identifier for the created scheduler

#### Response Example
```json
{
  "scheduler_id": "scheduler-123"
}
```
```

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

### Create and Initialize SessionState in Rust

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/runtimes/session.rs.html

Demonstrates creating a new SessionState with initial values for state, step, frontier, and scheduler. Use this to start a new workflow execution.

```rust
use weavegraph::runtimes::SessionState;
use weavegraph::state::VersionedState;
use weavegraph::types::NodeKind;
use weavegraph::schedulers::{Scheduler, SchedulerState};

let session = SessionState {
    state: VersionedState::new_with_user_message("Hello"),
    step: 0,
    frontier: vec![NodeKind::Custom("start".into())],
    scheduler: Scheduler::new(4),
    scheduler_state: SchedulerState::default(),
};

assert_eq!(session.step, 0);
```

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

### GET /to_dot

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/graphs/struct.GraphBuilder.html

Exports the graph structure into DOT format for visualization.

```APIDOC
## GET /to_dot

### Description
Exports the graph to DOT format for visualization using Graphviz. Requires `petgraph-compat` feature.

### Method
GET

### Response
#### Success Response (200)
- **String** (String) - The graph representation in DOT format
```

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

### Get dropped subscriber count

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/event_bus/hub/struct.EventHub.html

Returns the number of subscribers that have been dropped.

```rust
pub fn dropped(&self) -> usize
```

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

### Creating Scoped ErrorEvents

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/channels/errors/struct.ErrorEvent.html

Examples of creating error events with different scopes.

```rust
use weavegraph::channels::errors::{ErrorEvent, WeaveError};

let err = ErrorEvent::node("my_node", 1, WeaveError::msg("Something failed"));
```

```rust
use weavegraph::channels::errors::{ErrorEvent, WeaveError};

let err = ErrorEvent::scheduler(5, WeaveError::msg("Scheduling conflict"));
```

```rust
use weavegraph::channels::errors::{ErrorEvent, WeaveError};

let err = ErrorEvent::runner("session_123", 10, WeaveError::msg("Runtime error"));
```

```rust
use weavegraph::channels::errors::{ErrorEvent, WeaveError};

let err = ErrorEvent::app(WeaveError::msg("Application startup failed"));
```

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

### Scheduler::record_seen

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/schedulers/scheduler/struct.Scheduler.html

Records the channel versions seen by a node at the start of its execution.

```APIDOC
## pub fn record_seen(&self, state: &mut SchedulerState, node_id: &str, snap: &StateSnapshot)

### Description
Record the versions seen for a node at the start of its execution.
This method updates the scheduler state to track which versions of each channel a node has processed. This information is used by version gating to determine whether a node needs to run again in future supersteps.
The versions are captured from the pre-barrier snapshot to ensure consistency with the state the node actually processes.

### Parameters
- **state** (mutable SchedulerState) - Mutable scheduler state to update with version information.
- **node_id** (str) - String identifier of the node (typically `format!("{:?}", node_kind)`).
- **snap** (StateSnapshot) - State snapshot containing current channel versions.

### Example
```rust
use weavegraph::channels::Channel;
use weavegraph::schedulers::{Scheduler, SchedulerState};
use weavegraph::state::VersionedState;

let scheduler = Scheduler::new(2);
let mut state = SchedulerState::default();

let mut snapshot_state = VersionedState::builder().build();
snapshot_state.messages.set_version(5);
snapshot_state.extra.set_version(3);
let snapshot = snapshot_state.snapshot();

// Record that node_a has processed versions 5 and 3
scheduler.record_seen(&mut state, "node_a", &snapshot);

// Future checks will use this information
assert!(!scheduler.should_run(&state, "node_a", &snapshot));
```
```

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

### Initialize GraphBuilder

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/graphs/builder.rs.html

Creates a new instance of GraphBuilder with default configurations.

```rust
#[must_use]
pub fn new() -> Self {
    Self {
        nodes: FxHashMap::default(),
        edges: FxHashMap::default(),
        conditional_edges: Vec::new(),
        runtime_config: RuntimeConfig::default(),
        reducer_registry: ReducerRegistry::default(),
    }
}
```

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

### GET /to_petgraph

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/graphs/struct.GraphBuilder.html

Converts the graph to a petgraph DiGraph for advanced algorithmic analysis.

```APIDOC
## GET /to_petgraph

### Description
Converts the graph to a petgraph `DiGraph` for advanced algorithms like shortest path or max flow. Requires `petgraph-compat` feature.

### Method
GET

### Response
#### Success Response (200)
- **PetgraphConversion** (Object) - The converted petgraph representation
```

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

### PostgresCheckpointer::connect

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/runtimes/checkpointer_postgres.rs.html

Establishes a connection to a PostgreSQL database and initializes the checkpointer. It also runs embedded migrations if the `postgres-migrations` feature is enabled.

```APIDOC
## POST /connect

### Description
Connect to a PostgreSQL database at `database_url`. Example URL: "postgresql://user:password@localhost/weavegraph". Returns a configured `PostgresCheckpointer` ready for use.

### Method
POST

### Endpoint
/connect

#### Query Parameters
- **database_url** (string) - Required - The connection string for the PostgreSQL database.

### Request Example
```json
{
  "database_url": "postgresql://user:password@localhost/weavegraph"
}
```

### Response
#### Success Response (200)
- **PostgresCheckpointer** (object) - A configured PostgresCheckpointer instance.

#### Response Example
```json
{
  "message": "Successfully connected to the database."
}
```
```

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

### Get chunk from LLMStreamingEvent

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/event_bus/event/struct.LLMStreamingEvent.html

Returns the string chunk of data associated with the event.

```rust
pub fn chunk(&self) -> &str
```

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

### Get stream ID from LLMStreamingEvent

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/event_bus/event/struct.LLMStreamingEvent.html

Returns the stream ID associated with the event, if any.

```rust
pub fn stream_id(&self) -> Option<&str>
```

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

### PostgresCheckpointer - Connect

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/runtimes/checkpointer_postgres/struct.PostgresCheckpointer.html

Establishes a connection to a PostgreSQL database to initialize the PostgresCheckpointer.

```APIDOC
## POST /connect

### Description
Connect to a PostgreSQL database at `database_url`. Example URL: "postgresql://user:password@localhost/weavegraph"
Returns a configured `PostgresCheckpointer` ready for use.

### Method
POST

### Endpoint
`/connect`

### Parameters
#### Query Parameters
- **database_url** (string) - Required - The connection URL for the PostgreSQL database.

### Response
#### Success Response (200)
- **PostgresCheckpointer** (object) - A configured PostgresCheckpointer instance.

#### Response Example
```json
{
  "message": "Connected successfully"
}
```
```

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

### Get node ID from LLMStreamingEvent

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/event_bus/event/struct.LLMStreamingEvent.html

Returns the node ID associated with the event, if any.

```rust
pub fn node_id(&self) -> Option<&str>
```

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

### Get session ID from LLMStreamingEvent

Source: https://docs.rs/weavegraph/0.3.0/weavegraph/event_bus/event/struct.LLMStreamingEvent.html

Returns the session ID associated with the event, if any.

```rust
pub fn session_id(&self) -> Option<&str>
```

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

### GET /sessions/{session_id}

Source: https://docs.rs/weavegraph/0.3.0/src/weavegraph/runtimes/checkpointer.rs.html

Retrieves the latest checkpoint for a specific session ID.

```APIDOC
## GET /sessions/{session_id}

### Description
Retrieves the latest checkpoint associated with the provided session identifier.

### Method
GET

### Endpoint
/sessions/{session_id}

### Parameters
#### Path Parameters
- **session_id** (string) - Required - The unique identifier for the session.

### Response
#### Success Response (200)
- **checkpoint** (Checkpoint) - The latest checkpoint object if found, otherwise null.
```
Tokens:
Raw