RetryMode

Author: nassor

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "cano"
-version = "0.1.3"
+version = "0.1.4"
 edition = "2024"
 description = "Simple & Fast Async Workflows in Rust - Build powerful data processing pipelines with minimal code"
 license = "MIT"
@@ -13,12 +13,12 @@ authors = ["Nassor Frazier-Silva"]
 [dependencies]
 async-trait = "0.1"
 tokio = { version = "1.0", features = ["full"] }
+rand = "0.9"
 
 [dev-dependencies]
 cargo-audit = "0.21.2"
 criterion = { version = "0.6", features = ["html_reports", "async_tokio"] }
 futures = "0.3"
-rand = "0.9"
 reqwest = { version = "0.12", features = ["json"] }
 
 [[example]]

Cargo.toml

@@ -87,8 +87,8 @@ That's it! You just ran your first Cano workflow.
 
 - **🏗️ Simple API**: A single `Node` trait handles everything - no complex type hierarchies
 - **🔗 Simple Configuration**: Fluent builder pattern makes setup intuitive  
-- **🔄 Built-in Retries**: Configurable retry logic for resilient workflows
-- **💾 Shared store**: Thread-safe key-value store for data passing between nodes
+- **🔄 Smart Retries**: Multiple retry strategies (none, fixed, exponential backoff) with jitter support
+- **💾 Shared Store**: Thread-safe key-value store for data passing between nodes
 - **🌊 Complex Workflows**: Chain nodes together into sophisticated state machine pipelines
 - **⚡ Type Safety**: Enum-driven state transitions with compile-time safety
 - **🚀 High Performance**: Minimal overhead with direct execution for maximum throughput
@@ -178,16 +178,71 @@ let result = flow.orchestrate(&store).await?;
 
 ### Built-in Retry Logic
 
-Every node includes configurable retry logic:
+Every node includes configurable retry logic with multiple strategies:
+
+#### Retry Modes
+
+**No Retries** - Fail fast for critical operations:
 
 ```rust
-let config = NodeConfig::new()
-    .with_retries(5, Duration::from_secs(1));  // 5 retries, 1s wait between attempts
+impl Node<WorkflowState> for CriticalNode {
+    fn config(&self) -> NodeConfig {
+        NodeConfig::minimal()  // No retries, fail immediately
+    }
+    // ... rest of implementation
+}
+```
+
+**Fixed Retries** - Consistent delays between attempts:
 
-// Or use minimal retries for fast-failing nodes
-let config = NodeConfig::minimal();  // 1 retry, no wait
+```rust
+impl Node<WorkflowState> for ReliableNode {
+    fn config(&self) -> NodeConfig {
+        NodeConfig::new().with_fixed_retry(3, Duration::from_secs(2))
+        // 3 retries with 2 second delays
+    }
+    // ... rest of implementation
+}
 ```
 
+**Exponential Backoff** - Smart retry with increasing delays:
+
+```rust
+impl Node<WorkflowState> for ResilientNode {
+    fn config(&self) -> NodeConfig {
+        NodeConfig::new().with_exponential_retry(5)
+        // 5 retries with exponential backoff (100ms, 200ms, 400ms, 800ms, 1.6s)
+    }
+    // ... rest of implementation
+}
+```
+
+**Custom Exponential Backoff** - Full control over retry behavior:
+
+```rust
+impl Node<WorkflowState> for CustomNode {
+    fn config(&self) -> NodeConfig {
+        NodeConfig::new().with_retry(
+            RetryMode::exponential_custom(
+                3,                              // max retries
+                Duration::from_millis(50),      // base delay
+                3.0,                            // multiplier  
+                Duration::from_secs(10),        // max delay cap
+                0.2,                            // 20% jitter
+            )
+        )
+    }
+    // ... rest of implementation
+}
+```
+
+#### Why Use Different Retry Modes?
+
+- **None**: Database transactions, critical validations where failure should be immediate
+- **Fixed**: Network calls, file operations where consistent timing is preferred  
+- **Exponential**: API calls, external services where you want to back off gracefully
+- **Custom Exponential**: High-load scenarios where you need precise control over timing and jitter
+
 ### Complex Workflows
 
 Chain multiple nodes together to build sophisticated state machine pipelines:

README.md

@@ -271,7 +271,7 @@ impl Node<BookPrepositionAction> for BookDownloaderNode {
     }
 
     fn config(&self) -> NodeConfig {
-        NodeConfig::new().with_retries(2, Duration::from_secs(1))
+        NodeConfig::new().with_fixed_retry(2, Duration::from_secs(1))
     }
 
     /// Preparation: Get the list of books to download

examples/book_prepositions.rs

@@ -234,7 +234,7 @@ where
         }
     }
 
-    /// Register a node for a specific state (accepts any type implementing Node<T>)
+    /// Register a node for a specific state (accepts any type implementing `Node<T>`)
     pub fn register_node<N>(&mut self, state: T, node: N) -> &mut Self
     where
         N: Node<T, crate::node::DefaultParams, S> + Send + Sync + 'static,
@@ -339,7 +339,7 @@ where
         }
     }
 
-    /// Register a node for a state (accepts any type implementing Node<T>)
+    /// Register a node for a state (accepts any type implementing `Node<T>`)
     pub fn register_node<N>(mut self, state: T, node: N) -> Self
     where
         N: Node<T, crate::node::DefaultParams, S> + Send + Sync + 'static,

src/flow.rs

@@ -79,7 +79,7 @@ pub mod store;
 // Core public API - simplified imports
 pub use error::{CanoError, CanoResult};
 pub use flow::{Flow, FlowBuilder};
-pub use node::{DefaultNodeResult, DefaultParams, DynNode, Node, NodeConfig};
+pub use node::{DefaultNodeResult, DefaultParams, DynNode, Node, NodeConfig, RetryMode};
 pub use store::{MemoryStore, Store};
 
 // Convenience re-exports for common patterns
@@ -90,7 +90,7 @@ pub mod prelude {
 
     pub use crate::{
         CanoError, CanoResult, DefaultNodeResult, DefaultParams, Flow, FlowBuilder, MemoryStore,
-        Node, NodeConfig, Store,
+        Node, NodeConfig, RetryMode, Store,
     };
 
     // Re-export async_trait for convenience