daa-ai 0.2.1

AI integration layer for DAA system with MCP protocol
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! Decision making engine and context

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

use crate::error::{AiError, Result};

/// Decision context containing relevant information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DecisionContext {
    pub context_id: String,
    pub decision_type: String,
    pub data: HashMap<String, serde_json::Value>,
    pub constraints: Vec<String>,
    pub timestamp: DateTime<Utc>,
}

impl DecisionContext {
    pub fn new(context_id: String, decision_type: String) -> Self {
        Self {
            context_id,
            decision_type,
            data: HashMap::new(),
            constraints: Vec::new(),
            timestamp: Utc::now(),
        }
    }

    pub fn add_data(&mut self, key: String, value: serde_json::Value) {
        self.data.insert(key, value);
    }

    pub fn add_constraint(&mut self, constraint: String) {
        self.constraints.push(constraint);
    }
}

/// Decision made by the agent
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Decision {
    pub decision_id: String,
    pub context_id: String,
    pub action: String,
    pub parameters: HashMap<String, serde_json::Value>,
    pub confidence: f64,
    pub reasoning: String,
    pub timestamp: DateTime<Utc>,
}

impl Decision {
    pub fn new(decision_id: String, context_id: String, action: String) -> Self {
        Self {
            decision_id,
            context_id,
            action,
            parameters: HashMap::new(),
            confidence: 0.5,
            reasoning: String::new(),
            timestamp: Utc::now(),
        }
    }

    pub fn with_confidence(mut self, confidence: f64) -> Self {
        self.confidence = confidence;
        self
    }

    pub fn with_reasoning(mut self, reasoning: String) -> Self {
        self.reasoning = reasoning;
        self
    }
}

/// Decision making engine
pub struct DecisionEngine {
    engine_id: String,
    initialized: bool,
}

impl DecisionEngine {
    pub fn new() -> Self {
        Self {
            engine_id: "default".to_string(),
            initialized: true,
        }
    }

    pub fn is_initialized(&self) -> bool {
        self.initialized
    }

    pub async fn make_decision(&self, context: &DecisionContext) -> Result<Decision> {
        // Mock decision making
        let decision = Decision::new(
            format!("decision_{}", chrono::Utc::now().timestamp()),
            context.context_id.clone(),
            "mock_action".to_string(),
        ).with_confidence(0.8)
         .with_reasoning("Mock decision based on context".to_string());

        Ok(decision)
    }
}

impl Default for DecisionEngine {
    fn default() -> Self {
        Self::new()
    }
}

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

    #[test]
    fn test_decision_context() {
        let mut context = DecisionContext::new(
            "ctx_1".to_string(),
            "trading".to_string(),
        );

        context.add_data("price".to_string(), serde_json::json!(100.0));
        context.add_constraint("max_risk".to_string());

        assert_eq!(context.data.len(), 1);
        assert_eq!(context.constraints.len(), 1);
    }

    #[tokio::test]
    async fn test_decision_engine() {
        let engine = DecisionEngine::new();
        assert!(engine.is_initialized());

        let context = DecisionContext::new(
            "ctx_1".to_string(),
            "test".to_string(),
        );

        let decision = engine.make_decision(&context).await.unwrap();
        assert_eq!(decision.context_id, "ctx_1");
        assert!(decision.confidence > 0.0);
    }
}