weavegraph 0.7.0

Graph-driven, concurrent agent workflow framework with versioned state, deterministic barrier merges, and rich diagnostics.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

//! Edge types and routing predicates for conditional graph flow.

use crate::types::NodeKind;
use std::sync::Arc;

/// Predicate function for conditional edge routing.
///
/// Receives a [`StateSnapshot`](crate::state::StateSnapshot) and returns the names of target
/// nodes to execute next. Used with
/// [`GraphBuilder::add_conditional_edge`](crate::graphs::GraphBuilder::add_conditional_edge).
///
/// # Examples
///
/// ```
/// use weavegraph::graphs::EdgePredicate;
/// use weavegraph::types::NodeKind;
/// use std::sync::Arc;
///
/// let route: EdgePredicate = Arc::new(|snapshot| {
///     if snapshot.messages.len() > 5 {
///         vec![NodeKind::Custom("many_messages".into()).as_target()]
///     } else {
///         vec![NodeKind::Custom("few_messages".into()).as_target()]
///     }
/// });
/// ```
pub type EdgePredicate =
    Arc<dyn Fn(crate::state::StateSnapshot) -> Vec<String> + Send + Sync + 'static>;

/// A conditional edge that routes to nodes determined by a predicate.
///
/// When the scheduler encounters a conditional edge it calls the predicate
/// with the current state and dispatches to the returned target nodes.
///
/// # Examples
///
/// ```
/// use weavegraph::graphs::{ConditionalEdge, EdgePredicate};
/// use weavegraph::types::NodeKind;
/// use std::sync::Arc;
///
/// let predicate: EdgePredicate = Arc::new(|snapshot| {
///     if snapshot.messages.len() > 5 {
///         vec![NodeKind::Custom("many_messages".into()).as_target()]
///     } else {
///         vec![NodeKind::Custom("few_messages".into()).as_target()]
///     }
/// });
/// let edge = ConditionalEdge::new(NodeKind::Start, predicate);
/// ```
#[derive(Clone)]
pub struct ConditionalEdge {
    // Source node for this edge.
    from: NodeKind,
    // Routing predicate.
    predicate: EdgePredicate,
}

impl ConditionalEdge {
    /// Creates a conditional edge from `from` to the targets returned by `predicate`.
    pub fn new(from: impl Into<NodeKind>, predicate: EdgePredicate) -> Self {
        Self {
            from: from.into(),
            predicate,
        }
    }

    /// Returns the source node.
    pub fn from(&self) -> &NodeKind {
        &self.from
    }

    /// Returns the routing predicate.
    pub fn predicate(&self) -> &EdgePredicate {
        &self.predicate
    }
}