enya-agent 0.1.0

package/crates/enact-core/src/flow/sequential.rs

@@ -0,0 +1,248 @@
+//! Sequential Flow - Execute callables one after another
+//!
+//! The output of each step becomes the input to the next.
+
+use crate::callable::Callable;
+use std::sync::Arc;
+
+/// Sequential execution flow
+pub struct SequentialFlow<C: Callable> {
+    /// Ordered list of callables to execute
+    steps: Vec<Arc<C>>,
+    /// Flow name
+    name: String,
+}
+
+impl<C: Callable> SequentialFlow<C> {
+    /// Create a new sequential flow
+    pub fn new(name: impl Into<String>) -> Self {
+        Self {
+            steps: Vec::new(),
+            name: name.into(),
+        }
+    }
+
+    /// Add a step to the flow
+    pub fn add_step(mut self, callable: Arc<C>) -> Self {
+        self.steps.push(callable);
+        self
+    }
+
+    /// Add multiple steps
+    pub fn with_steps(mut self, callables: Vec<Arc<C>>) -> Self {
+        self.steps.extend(callables);
+        self
+    }
+
+    /// Execute the flow
+    pub async fn execute(&self, input: &str) -> anyhow::Result<String> {
+        let mut current_output = input.to_string();
+
+        for step in &self.steps {
+            current_output = step.run(&current_output).await?;
+        }
+
+        Ok(current_output)
+    }
+
+    /// Get the flow name
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    /// Get the number of steps
+    pub fn len(&self) -> usize {
+        self.steps.len()
+    }
+
+    /// Check if empty
+    pub fn is_empty(&self) -> bool {
+        self.steps.is_empty()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use async_trait::async_trait;
+
+    /// Mock callable for testing - transforms input in a predictable way
+    struct MockCallable {
+        name: String,
+        transform: Box<dyn Fn(&str) -> String + Send + Sync>,
+    }
+
+    impl MockCallable {
+        fn new(name: &str, transform: impl Fn(&str) -> String + Send + Sync + 'static) -> Self {
+            Self {
+                name: name.to_string(),
+                transform: Box::new(transform),
+            }
+        }
+
+        fn uppercase(name: &str) -> Self {
+            Self::new(name, |s| s.to_uppercase())
+        }
+
+        fn append(name: &str, suffix: &'static str) -> Self {
+            Self::new(name, move |s| format!("{}{}", s, suffix))
+        }
+
+        fn prepend(name: &str, prefix: &'static str) -> Self {
+            Self::new(name, move |s| format!("{}{}", prefix, s))
+        }
+    }
+
+    #[async_trait]
+    impl Callable for MockCallable {
+        fn name(&self) -> &str {
+            &self.name
+        }
+
+        async fn run(&self, input: &str) -> anyhow::Result<String> {
+            Ok((self.transform)(input))
+        }
+    }
+
+    #[tokio::test]
+    async fn test_sequential_empty() {
+        let flow: SequentialFlow<MockCallable> = SequentialFlow::new("empty");
+        assert!(flow.is_empty());
+        assert_eq!(flow.len(), 0);
+
+        let result = flow.execute("input").await.unwrap();
+        assert_eq!(result, "input"); // No steps = input passes through
+    }
+
+    #[tokio::test]
+    async fn test_sequential_single_step() {
+        let step = Arc::new(MockCallable::uppercase("upper"));
+        let flow = SequentialFlow::new("single").add_step(step);
+
+        assert_eq!(flow.len(), 1);
+        assert!(!flow.is_empty());
+        assert_eq!(flow.name(), "single");
+
+        let result = flow.execute("hello").await.unwrap();
+        assert_eq!(result, "HELLO");
+    }
+
+    #[tokio::test]
+    async fn test_sequential_multiple_steps() {
+        let flow = SequentialFlow::new("chain")
+            .add_step(Arc::new(MockCallable::uppercase("step1")))
+            .add_step(Arc::new(MockCallable::append("step2", "!")))
+            .add_step(Arc::new(MockCallable::prepend("step3", ">> ")));
+
+        assert_eq!(flow.len(), 3);
+
+        let result = flow.execute("hello").await.unwrap();
+        assert_eq!(result, ">> HELLO!");
+    }
+
+    #[tokio::test]
+    async fn test_sequential_with_steps() {
+        let steps = vec![
+            Arc::new(MockCallable::uppercase("s1")),
+            Arc::new(MockCallable::append("s2", "_done")),
+        ];
+        let flow = SequentialFlow::new("batch").with_steps(steps);
+
+        assert_eq!(flow.len(), 2);
+        let result = flow.execute("test").await.unwrap();
+        assert_eq!(result, "TEST_done");
+    }
+
+    #[tokio::test]
+    async fn test_sequential_error_propagation() {
+        struct FailingCallable {
+            name: String,
+            fail_on_call: usize,
+            call_count: std::sync::atomic::AtomicUsize,
+        }
+
+        impl FailingCallable {
+            fn new(name: &str, fail_on: usize) -> Self {
+                Self {
+                    name: name.to_string(),
+                    fail_on_call: fail_on,
+                    call_count: std::sync::atomic::AtomicUsize::new(0),
+                }
+            }
+        }
+
+        #[async_trait]
+        impl Callable for FailingCallable {
+            fn name(&self) -> &str {
+                &self.name
+            }
+
+            async fn run(&self, input: &str) -> anyhow::Result<String> {
+                let n = self.call_count.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+                if n >= self.fail_on_call {
+                    anyhow::bail!("Intentional failure at step {}", n)
+                }
+                Ok(input.to_uppercase())
+            }
+        }
+
+        // Flow of 3 FailingCallable steps, second one fails
+        let flow = SequentialFlow::new("with_error")
+            .add_step(Arc::new(FailingCallable::new("step1", 10)))  // Won't fail
+            .add_step(Arc::new(FailingCallable::new("step2", 0)))   // Fails immediately
+            .add_step(Arc::new(FailingCallable::new("step3", 10))); // Never reached
+
+        let result = flow.execute("hello").await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().to_string().contains("Intentional failure"));
+    }
+
+    #[tokio::test]
+    async fn test_sequential_preserves_order() {
+        use std::sync::atomic::{AtomicUsize, Ordering};
+
+        let counter = Arc::new(AtomicUsize::new(0));
+        let execution_order = Arc::new(std::sync::Mutex::new(Vec::new()));
+
+        struct OrderTracker {
+            name: String,
+            counter: Arc<AtomicUsize>,
+            order: Arc<std::sync::Mutex<Vec<usize>>>,
+        }
+
+        #[async_trait]
+        impl Callable for OrderTracker {
+            fn name(&self) -> &str {
+                &self.name
+            }
+
+            async fn run(&self, input: &str) -> anyhow::Result<String> {
+                let n = self.counter.fetch_add(1, Ordering::SeqCst);
+                self.order.lock().unwrap().push(n);
+                Ok(input.to_string())
+            }
+        }
+
+        let flow = SequentialFlow::new("ordered")
+            .add_step(Arc::new(OrderTracker {
+                name: "first".to_string(),
+                counter: counter.clone(),
+                order: execution_order.clone(),
+            }))
+            .add_step(Arc::new(OrderTracker {
+                name: "second".to_string(),
+                counter: counter.clone(),
+                order: execution_order.clone(),
+            }))
+            .add_step(Arc::new(OrderTracker {
+                name: "third".to_string(),
+                counter: counter.clone(),
+                order: execution_order.clone(),
+            }));
+
+        flow.execute("test").await.unwrap();
+
+        let order = execution_order.lock().unwrap();
+        assert_eq!(*order, vec![0, 1, 2]);
+    }
+}

package/crates/enact-core/src/graph/checkpoint.rs

@@ -0,0 +1,79 @@
+//! Checkpoint types for save/resume execution
+
+use crate::kernel::{GraphId, RunId};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::collections::HashMap;
+use svix_ksuid::KsuidLike;
+
+/// Checkpoint - saved state of execution
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Checkpoint {
+    /// Unique checkpoint ID
+    pub id: String,
+    /// Run this checkpoint belongs to
+    pub run_id: RunId,
+    /// Graph being executed
+    pub graph_id: Option<GraphId>,
+    /// Current node in execution
+    pub current_node: Option<String>,
+    /// State at this checkpoint
+    pub state: Value,
+    /// Messages history (for LLM agents)
+    pub messages: Vec<MessageRecord>,
+    /// Tool results collected so far
+    pub tool_results: HashMap<String, Value>,
+    /// Created timestamp
+    pub created_at: chrono::DateTime<chrono::Utc>,
+    /// Metadata
+    pub metadata: HashMap<String, Value>,
+}
+
+/// Message record for checkpoint
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MessageRecord {
+    pub role: String,
+    pub content: String,
+}
+
+impl Checkpoint {
+    /// Create a new checkpoint
+    pub fn new(run_id: RunId) -> Self {
+        Self {
+            id: format!("ckpt_{}", svix_ksuid::Ksuid::new(None, None)),
+            run_id,
+            graph_id: None,
+            current_node: None,
+            state: Value::Null,
+            messages: Vec::new(),
+            tool_results: HashMap::new(),
+            created_at: chrono::Utc::now(),
+            metadata: HashMap::new(),
+        }
+    }
+
+    /// Set the current state
+    pub fn with_state(mut self, state: Value) -> Self {
+        self.state = state;
+        self
+    }
+
+    /// Set the current node
+    pub fn with_node(mut self, node: impl Into<String>) -> Self {
+        self.current_node = Some(node.into());
+        self
+    }
+
+    /// Add a message to history
+    pub fn add_message(&mut self, role: impl Into<String>, content: impl Into<String>) {
+        self.messages.push(MessageRecord {
+            role: role.into(),
+            content: content.into(),
+        });
+    }
+
+    /// Add a tool result
+    pub fn add_tool_result(&mut self, tool_name: impl Into<String>, result: Value) {
+        self.tool_results.insert(tool_name.into(), result);
+    }
+}

package/crates/enact-core/src/graph/checkpoint_store.rs

@@ -0,0 +1,76 @@
+//! Checkpoint store trait and implementations
+
+use super::Checkpoint;
+use async_trait::async_trait;
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
+
+/// Checkpoint store trait
+#[async_trait]
+pub trait CheckpointStore: Send + Sync {
+    /// Save a checkpoint
+    async fn save(&self, checkpoint: Checkpoint) -> anyhow::Result<()>;
+
+    /// Load a checkpoint by ID
+    async fn load(&self, id: &str) -> anyhow::Result<Option<Checkpoint>>;
+
+    /// Load latest checkpoint for a run
+    async fn load_latest(&self, run_id: &str) -> anyhow::Result<Option<Checkpoint>>;
+
+    /// List checkpoints for a run
+    async fn list(&self, run_id: &str) -> anyhow::Result<Vec<Checkpoint>>;
+
+    /// Delete a checkpoint
+    async fn delete(&self, id: &str) -> anyhow::Result<()>;
+}
+
+/// In-memory checkpoint store (for testing/development)
+#[derive(Default)]
+pub struct InMemoryCheckpointStore {
+    checkpoints: Arc<RwLock<HashMap<String, Checkpoint>>>,
+}
+
+impl InMemoryCheckpointStore {
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
+#[async_trait]
+impl CheckpointStore for InMemoryCheckpointStore {
+    async fn save(&self, checkpoint: Checkpoint) -> anyhow::Result<()> {
+        let mut store = self.checkpoints.write().unwrap();
+        store.insert(checkpoint.id.clone(), checkpoint);
+        Ok(())
+    }
+
+    async fn load(&self, id: &str) -> anyhow::Result<Option<Checkpoint>> {
+        let store = self.checkpoints.read().unwrap();
+        Ok(store.get(id).cloned())
+    }
+
+    async fn load_latest(&self, run_id: &str) -> anyhow::Result<Option<Checkpoint>> {
+        let store = self.checkpoints.read().unwrap();
+        let latest = store
+            .values()
+            .filter(|c| c.run_id.as_str() == run_id)
+            .max_by_key(|c| c.created_at);
+        Ok(latest.cloned())
+    }
+
+    async fn list(&self, run_id: &str) -> anyhow::Result<Vec<Checkpoint>> {
+        let store = self.checkpoints.read().unwrap();
+        let checkpoints: Vec<_> = store
+            .values()
+            .filter(|c| c.run_id.as_str() == run_id)
+            .cloned()
+            .collect();
+        Ok(checkpoints)
+    }
+
+    async fn delete(&self, id: &str) -> anyhow::Result<()> {
+        let mut store = self.checkpoints.write().unwrap();
+        store.remove(id);
+        Ok(())
+    }
+}

package/crates/enact-core/src/graph/compiled.rs

@@ -0,0 +1,189 @@
+//! CompiledGraph - validated and ready-to-execute graph
+//!
+//! Supports parallel execution when multiple targets are available.
+
+use super::edge::{ConditionalEdge, Edge, EdgeTarget};
+use super::node::{DynNode, NodeState};
+use futures::future::join_all;
+use std::collections::HashMap;
+
+/// Compiled graph - validated and ready to execute
+pub struct CompiledGraph {
+    pub(crate) nodes: HashMap<String, DynNode>,
+    pub(crate) edges: Vec<Edge>,
+    pub(crate) conditional_edges: Vec<ConditionalEdge>,
+    pub(crate) entry_point: String,
+}
+
+impl CompiledGraph {
+    /// Get a node by name
+    pub fn get_node(&self, name: &str) -> Option<&DynNode> {
+        self.nodes.get(name)
+    }
+
+    /// Get the entry point
+    pub fn entry_point(&self) -> &str {
+        &self.entry_point
+    }
+
+    /// Get the next node(s) after the given node
+    pub fn get_next(&self, from: &str, output: &str) -> Vec<EdgeTarget> {
+        let mut targets = Vec::new();
+
+        // Check conditional edges first
+        for ce in &self.conditional_edges {
+            if ce.from == from {
+                targets.push((ce.router)(output));
+            }
+        }
+
+        // Then check regular edges
+        for edge in &self.edges {
+            if edge.from == from {
+                targets.push(edge.to.clone());
+            }
+        }
+
+        targets
+    }
+
+    /// Run the graph with an initial input
+    pub async fn run(&self, input: impl Into<String>) -> anyhow::Result<NodeState> {
+        let initial_state = NodeState::from_str(&input.into());
+        self.run_with_state(initial_state).await
+    }
+
+    /// Run the graph with an initial state
+    ///
+    /// When multiple targets are available, executes them in parallel.
+    /// This implements the Agentic DAG execution model where independent
+    /// nodes can run concurrently.
+    pub async fn run_with_state(&self, initial_state: NodeState) -> anyhow::Result<NodeState> {
+        let mut current_node = self.entry_point.clone();
+        let mut state = initial_state;
+
+        loop {
+            // Get the current node
+            let node = self
+                .nodes
+                .get(&current_node)
+                .ok_or_else(|| anyhow::anyhow!("Node '{}' not found", current_node))?;
+
+            // Execute the node
+            tracing::debug!(node = %current_node, "Executing node");
+            state = node.execute(state).await?;
+
+            // Get the output for routing
+            let output = state.as_str().unwrap_or_default().to_string();
+
+            // Find next node(s)
+            let next_targets = self.get_next(&current_node, &output);
+
+            if next_targets.is_empty() {
+                // No outgoing edges - end execution
+                tracing::debug!(node = %current_node, "No outgoing edges, ending");
+                break;
+            }
+
+            // Check for END target
+            let has_end = next_targets.iter().any(|t| matches!(t, EdgeTarget::End));
+            if has_end {
+                tracing::debug!("Reached END");
+                break;
+            }
+
+            // Collect node targets (filter out End)
+            let node_targets: Vec<String> = next_targets
+                .iter()
+                .filter_map(|t| match t {
+                    EdgeTarget::Node(n) => Some(n.clone()),
+                    EdgeTarget::End => None,
+                })
+                .collect();
+
+            if node_targets.is_empty() {
+                break;
+            }
+
+            // Single target - sequential execution
+            if node_targets.len() == 1 {
+                current_node = node_targets[0].clone();
+                continue;
+            }
+
+            // Multiple targets - PARALLEL EXECUTION
+            tracing::debug!(
+                targets = ?node_targets,
+                "Executing {} nodes in parallel",
+                node_targets.len()
+            );
+
+            // Execute all target nodes in parallel
+            let parallel_results = self
+                .execute_nodes_parallel(&node_targets, state.clone())
+                .await?;
+
+            // Aggregate results: combine all outputs
+            // For now, we use the last successful result as the state
+            // In a full implementation, this would support custom aggregation strategies
+            if let Some(last_state) = parallel_results.into_iter().last() {
+                state = last_state;
+            }
+
+            // After parallel execution, check if any nodes have outgoing edges
+            // For simplicity, we end after parallel execution
+            // A full implementation would continue with fan-in logic
+            tracing::debug!("Parallel execution complete");
+            break;
+        }
+
+        Ok(state)
+    }
+
+    /// Execute multiple nodes in parallel
+    ///
+    /// Returns results from all nodes that completed successfully.
+    async fn execute_nodes_parallel(
+        &self,
+        node_names: &[String],
+        input_state: NodeState,
+    ) -> anyhow::Result<Vec<NodeState>> {
+        let futures: Vec<_> = node_names
+            .iter()
+            .filter_map(|name| {
+                self.nodes.get(name).map(|node| {
+                    let state = input_state.clone();
+                    let node_name = name.clone();
+                    async move {
+                        tracing::debug!(node = %node_name, "Executing parallel node");
+                        node.execute(state).await
+                    }
+                })
+            })
+            .collect();
+
+        let results = join_all(futures).await;
+
+        // Collect successful results
+        let successful: Vec<NodeState> = results
+            .into_iter()
+            .filter_map(|r| r.ok())
+            .collect();
+
+        if successful.is_empty() {
+            anyhow::bail!("All parallel nodes failed");
+        }
+
+        Ok(successful)
+    }
+
+    /// Get node count
+    pub fn node_count(&self) -> usize {
+        self.nodes.len()
+    }
+
+    /// Get edge count
+    pub fn edge_count(&self) -> usize {
+        self.edges.len() + self.conditional_edges.len()
+    }
+}

package/crates/enact-core/src/graph/edge.rs

@@ -0,0 +1,59 @@
+//! Edge types for graph connections
+
+/// Target for an edge - either a specific node or END
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum EdgeTarget {
+    /// Target a specific node by name
+    Node(String),
+    /// End the graph execution
+    End,
+}
+
+impl EdgeTarget {
+    pub fn node(name: impl Into<String>) -> Self {
+        Self::Node(name.into())
+    }
+
+    pub fn end() -> Self {
+        Self::End
+    }
+
+    pub fn is_end(&self) -> bool {
+        matches!(self, Self::End)
+    }
+}
+
+/// Edge in the graph
+#[derive(Debug, Clone)]
+pub struct Edge {
+    pub from: String,
+    pub to: EdgeTarget,
+}
+
+impl Edge {
+    pub fn new(from: impl Into<String>, to: EdgeTarget) -> Self {
+        Self {
+            from: from.into(),
+            to,
+        }
+    }
+}
+
+/// Conditional edge - routes based on a function
+#[derive(Clone)]
+pub struct ConditionalEdge {
+    pub from: String,
+    pub router: ConditionalRouter,
+}
+
+/// Router function type
+pub type ConditionalRouter = std::sync::Arc<dyn Fn(&str) -> EdgeTarget + Send + Sync>;
+
+impl std::fmt::Debug for ConditionalEdge {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ConditionalEdge")
+            .field("from", &self.from)
+            .field("router", &"<fn>")
+            .finish()
+    }
+}