ccswarm 0.4.2

AI-powered multi-agent orchestration system with proactive intelligence, security monitoring, and session management
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

use thiserror::Error;

/// Errors that can occur during session operations
#[derive(Debug, Error)]
pub enum SessionError {
    /// Session with the specified ID was not found
    #[error("Session not found: {id}")]
    NotFound { id: String },

    /// Session is in an invalid state for the requested operation
    #[error("Invalid session state: {state} for operation: {operation}")]
    InvalidState { state: String, operation: String },

    /// Failed to acquire a lock on session data
    #[error("Failed to acquire session lock: {reason}")]
    LockError { reason: String },

    /// Session creation failed
    #[error("Failed to create session: {reason}")]
    CreationFailed { reason: String },

    /// Session termination failed
    #[error("Failed to terminate session: {reason}")]
    TerminationFailed { reason: String },

    /// Resource monitoring error
    #[error("Resource monitoring error: {reason}")]
    ResourceError { reason: String },

    /// Context bridge error
    #[error("Context bridge error: {reason}")]
    ContextBridgeError { reason: String },

    /// Persistence error
    #[error("Session persistence error: {reason}")]
    PersistenceError { reason: String },

    /// Pool management error
    #[error("Session pool error: {reason}")]
    PoolError { reason: String },

    /// Memory management error
    #[error("Session memory error: {reason}")]
    MemoryError { reason: String },

    /// Generic error wrapping other error types
    #[error("Session error: {0}")]
    Other(#[from] anyhow::Error),
}

/// Result type alias for session operations
pub type SessionResult<T> = Result<T, SessionError>;

/// Extension trait for converting mutex errors to SessionError
pub trait LockResultExt<T> {
    /// Convert a poisoned mutex error to a SessionError
    fn map_lock_error(self) -> SessionResult<T>;
}

impl<T> LockResultExt<T> for std::sync::LockResult<T> {
    fn map_lock_error(self) -> SessionResult<T> {
        self.map_err(|e| SessionError::LockError {
            reason: format!("Mutex poisoned: {}", e),
        })
    }
}