ubiquity-core 0.1.1

Core types and traits for Ubiquity consciousness-aware mesh
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
145
146
147
148
149
150

//! Configuration types for Ubiquity

use serde::{Deserialize, Serialize};
use std::time::Duration;

/// LLM provider configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LLMConfig {
    pub provider: LLMProvider,
    pub api_key: String,
    pub model: String,
    pub temperature: f32,
    pub max_tokens: usize,
    pub timeout: Duration,
    pub retry_attempts: u32,
    pub retry_delay: Duration,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum LLMProvider {
    Claude,
    OpenAI,
    Local,
    Mock, // For testing
}

/// Security configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SecurityConfig {
    pub auth_enabled: bool,
    pub auth_type: AuthType,
    pub tls_enabled: bool,
    pub tls_cert_path: Option<String>,
    pub tls_key_path: Option<String>,
    pub allowed_origins: Vec<String>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum AuthType {
    None,
    Token,
    Certificate,
    ApiKey,
}

/// Transport configuration with timeout and retry
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TransportConfigExt {
    pub connect_timeout: Duration,
    pub read_timeout: Duration,
    pub write_timeout: Duration,
    pub keep_alive_interval: Duration,
    pub max_message_size: usize,
    pub retry_attempts: u32,
    pub retry_delay: Duration,
    pub exponential_backoff: bool,
    pub max_connections: usize,
}

impl Default for TransportConfigExt {
    fn default() -> Self {
        Self {
            connect_timeout: Duration::from_secs(30),
            read_timeout: Duration::from_secs(60),
            write_timeout: Duration::from_secs(30),
            keep_alive_interval: Duration::from_secs(30),
            max_message_size: 10 * 1024 * 1024, // 10MB
            retry_attempts: 3,
            retry_delay: Duration::from_secs(1),
            exponential_backoff: true,
            max_connections: 100,
        }
    }
}

/// Monitoring configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MonitoringConfig {
    pub metrics_enabled: bool,
    pub traces_enabled: bool,
    pub logs_level: LogLevel,
    pub metrics_port: u16,
    pub health_check_interval: Duration,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum LogLevel {
    Trace,
    Debug,
    Info,
    Warn,
    Error,
}

/// Complete Ubiquity configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UbiquityConfig {
    pub agent: AgentConfigExt,
    pub llm: Option<LLMConfig>,
    pub security: SecurityConfig,
    pub transport: TransportConfigExt,
    pub monitoring: MonitoringConfig,
}

/// Extended agent configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AgentConfigExt {
    pub default_consciousness_level: f64,
    pub consciousness_check_interval: Duration,
    pub task_timeout: Duration,
    pub max_concurrent_tasks: usize,
    pub enable_state_persistence: bool,
    pub state_save_interval: Duration,
}

impl Default for AgentConfigExt {
    fn default() -> Self {
        Self {
            default_consciousness_level: 0.85,
            consciousness_check_interval: Duration::from_secs(10),
            task_timeout: Duration::from_secs(300),
            max_concurrent_tasks: 10,
            enable_state_persistence: true,
            state_save_interval: Duration::from_secs(60),
        }
    }
}

/// Authentication token
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AuthToken {
    pub token: String,
    pub agent_id: String,
    pub capabilities: crate::AgentCapability,
    pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
}

/// Health status
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HealthStatus {
    pub healthy: bool,
    pub consciousness_level: f64,
    pub active_tasks: usize,
    pub memory_usage_mb: f64,
    pub uptime_seconds: u64,
    pub last_error: Option<String>,
}