terraphim_kg_agents 1.0.0

Specialized knowledge graph-based agent implementations
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
123
124
125
126

//! Error types for knowledge graph agents

use thiserror::Error;

use terraphim_task_decomposition::TaskDecompositionError;

// GenAgentError is defined in lib.rs since terraphim_gen_agent doesn't exist yet
use crate::GenAgentError;

/// Errors that can occur in knowledge graph agent operations
#[derive(Error, Debug)]
pub enum KgAgentError {
    /// Task decomposition failed
    #[error("Task decomposition failed: {0}")]
    DecompositionFailed(String),

    /// Knowledge graph query failed
    #[error("Knowledge graph query failed: {0}")]
    KnowledgeGraphError(String),

    /// Agent coordination failed
    #[error("Agent coordination failed: {0}")]
    CoordinationFailed(String),

    /// Task execution failed
    #[error("Task execution failed: {0}")]
    ExecutionFailed(String),

    /// Domain specialization error
    #[error("Domain specialization error: {0}")]
    DomainError(String),

    /// Task compatibility check failed
    #[error("Task compatibility check failed: {0}")]
    CompatibilityError(String),

    /// Planning error
    #[error("Planning error: {0}")]
    PlanningError(String),

    /// Worker agent error
    #[error("Worker agent error: {0}")]
    WorkerError(String),

    /// Coordination agent error
    #[error("Coordination agent error: {0}")]
    CoordinationAgentError(String),

    /// Generic GenAgent error
    #[error("GenAgent error: {0}")]
    GenAgentError(#[from] GenAgentError),

    /// Task decomposition error
    #[error("Task decomposition error: {0}")]
    TaskDecompositionError(#[from] TaskDecompositionError),

    /// System error
    #[error("System error: {0}")]
    SystemError(String),
}

impl KgAgentError {
    /// Check if the error is recoverable
    pub fn is_recoverable(&self) -> bool {
        match self {
            KgAgentError::DecompositionFailed(_) => true,
            KgAgentError::KnowledgeGraphError(_) => true,
            KgAgentError::CoordinationFailed(_) => true,
            KgAgentError::ExecutionFailed(_) => false, // Execution failures are usually not recoverable
            KgAgentError::DomainError(_) => false,
            KgAgentError::CompatibilityError(_) => false,
            KgAgentError::PlanningError(_) => true,
            KgAgentError::WorkerError(_) => true,
            KgAgentError::CoordinationAgentError(_) => true,
            KgAgentError::GenAgentError(_) => true, // TODO: implement is_recoverable() for GenAgentError
            KgAgentError::TaskDecompositionError(_) => true,
            KgAgentError::SystemError(_) => false,
        }
    }

    /// Get error category for logging and monitoring
    pub fn category(&self) -> &'static str {
        match self {
            KgAgentError::DecompositionFailed(_) => "decomposition",
            KgAgentError::KnowledgeGraphError(_) => "knowledge_graph",
            KgAgentError::CoordinationFailed(_) => "coordination",
            KgAgentError::ExecutionFailed(_) => "execution",
            KgAgentError::DomainError(_) => "domain",
            KgAgentError::CompatibilityError(_) => "compatibility",
            KgAgentError::PlanningError(_) => "planning",
            KgAgentError::WorkerError(_) => "worker",
            KgAgentError::CoordinationAgentError(_) => "coordination_agent",
            KgAgentError::GenAgentError(_) => "gen_agent",
            KgAgentError::TaskDecompositionError(_) => "task_decomposition",
            KgAgentError::SystemError(_) => "system",
        }
    }
}

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

    #[test]
    fn test_error_recoverability() {
        assert!(KgAgentError::DecompositionFailed("test".to_string()).is_recoverable());
        assert!(!KgAgentError::ExecutionFailed("test".to_string()).is_recoverable());
        assert!(!KgAgentError::SystemError("test".to_string()).is_recoverable());
    }

    #[test]
    fn test_error_categorization() {
        assert_eq!(
            KgAgentError::PlanningError("test".to_string()).category(),
            "planning"
        );
        assert_eq!(
            KgAgentError::WorkerError("test".to_string()).category(),
            "worker"
        );
        assert_eq!(
            KgAgentError::CoordinationFailed("test".to_string()).category(),
            "coordination"
        );
    }
}