swarm-engine-core 0.1.6

Core types and orchestration for SwarmEngine
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

//! Termination configuration
//!
//! Configuration for termination behavior.

use serde::{Deserialize, Serialize};

/// Termination configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TerminationConfig {
    /// Maximum ticks before timeout (0 = no limit)
    pub max_ticks: u64,

    /// Strategy for multi-worker termination
    pub multi_worker_strategy: MultiWorkerStrategy,

    /// Behavior when exploration is exhausted
    pub on_exhausted: ExhaustedBehavior,

    /// Maximum consecutive errors before failure
    pub max_consecutive_errors: Option<u64>,

    /// Whether to allow graceful shutdown period
    pub graceful_shutdown_ticks: u64,
}

impl Default for TerminationConfig {
    fn default() -> Self {
        Self {
            max_ticks: 1000,
            multi_worker_strategy: MultiWorkerStrategy::FirstSuccess,
            on_exhausted: ExhaustedBehavior::Fail,
            max_consecutive_errors: None,
            graceful_shutdown_ticks: 0,
        }
    }
}

/// Strategy for handling multiple workers
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum MultiWorkerStrategy {
    /// Terminate when first worker succeeds
    #[default]
    FirstSuccess,
    /// Terminate when all workers complete (success if any succeeded)
    AllComplete,
    /// Terminate when all workers succeed
    AllSuccess,
    /// Custom logic (check conditions)
    Conditions,
}

/// Behavior when exploration is exhausted
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum ExhaustedBehavior {
    /// Treat as failure
    #[default]
    Fail,
    /// Treat as success (exploration naturally completed)
    Success,
    /// Check conditions to determine outcome
    CheckConditions,
}

impl TerminationConfig {
    /// Create config with max_ticks
    pub fn with_max_ticks(max_ticks: u64) -> Self {
        Self {
            max_ticks,
            ..Default::default()
        }
    }

    /// Set multi-worker strategy
    pub fn multi_worker_strategy(mut self, strategy: MultiWorkerStrategy) -> Self {
        self.multi_worker_strategy = strategy;
        self
    }

    /// Set exhausted behavior
    pub fn on_exhausted(mut self, behavior: ExhaustedBehavior) -> Self {
        self.on_exhausted = behavior;
        self
    }

    /// Set max consecutive errors
    pub fn max_consecutive_errors(mut self, max: u64) -> Self {
        self.max_consecutive_errors = Some(max);
        self
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_default_config() {
        let config = TerminationConfig::default();
        assert_eq!(config.max_ticks, 1000);
        assert_eq!(
            config.multi_worker_strategy,
            MultiWorkerStrategy::FirstSuccess
        );
        assert_eq!(config.on_exhausted, ExhaustedBehavior::Fail);
    }

    #[test]
    fn test_builder_pattern() {
        let config = TerminationConfig::with_max_ticks(500)
            .multi_worker_strategy(MultiWorkerStrategy::AllSuccess)
            .on_exhausted(ExhaustedBehavior::Success);

        assert_eq!(config.max_ticks, 500);
        assert_eq!(
            config.multi_worker_strategy,
            MultiWorkerStrategy::AllSuccess
        );
        assert_eq!(config.on_exhausted, ExhaustedBehavior::Success);
    }
}