claw10-domain 0.2.3

Domain models and types for Claw10 OS
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

use serde::{Deserialize, Serialize};

use crate::agent::AgentId;
use crate::identity::IdentityId;
use crate::mission::MissionId;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModelProfile {
    pub id: String,
    pub provider: String,
    pub model_name: String,
    pub context_window: u32,
    pub max_output_tokens: u32,
    pub cost_per_1k_input: f64,
    pub cost_per_1k_output: f64,
    pub suitable_for: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModelProvider {
    pub id: String,
    pub name: String,
    pub base_url: String,
    pub api_key_ref: String,
    pub is_active: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RiskLevel(pub String);

impl RiskLevel {
    pub const LOW: &'static str = "low";
    pub const MEDIUM: &'static str = "medium";
    pub const HIGH: &'static str = "high";
    pub const CRITICAL: &'static str = "critical";
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Incident {
    pub id: String,
    pub mission_id: MissionId,
    pub agent_id: AgentId,
    pub severity: String,
    pub description: String,
    pub state: IncidentState,
    pub created_at: chrono::DateTime<chrono::Utc>,
    pub resolved_at: Option<chrono::DateTime<chrono::Utc>>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum IncidentState {
    Open,
    Investigating,
    Mitigating,
    Resolved,
    Closed,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Reputation {
    pub agent_id: AgentId,
    pub score: f64,
    pub total_tasks_completed: u64,
    pub total_tasks_accepted: u64,
    pub total_revisions: u64,
    pub average_confidence: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Channel {
    pub id: String,
    pub channel_type: ChannelType,
    pub config: serde_json::Value,
    pub is_active: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IncomingMessage {
    pub id: String,
    pub channel_id: String,
    pub sender_id: String,
    pub text: String,
    pub raw_payload: serde_json::Value,
    pub received_at: chrono::DateTime<chrono::Utc>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum ChannelType {
    Terminal,
    Rest,
    Webhook,
    Telegram,
    WhatsApp,
    Slack,
    Discord,
    Mobile,
    InternalBus,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Session {
    pub id: String,
    pub identity_id: IdentityId,
    pub channel_id: String,
    pub state: SessionState,
    pub created_at: chrono::DateTime<chrono::Utc>,
    pub expires_at: chrono::DateTime<chrono::Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum SessionState {
    Active,
    Idle,
    Expired,
    Terminated,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SwarmLimitsConfig {
    pub max_spawn_depth: u32,
    pub max_children_per_agent: u32,
    pub max_agents_per_mission: u32,
    pub max_concurrent_agents: u32,
    pub max_persistent_children_per_agent: u32,
    pub max_turns_per_ephemeral_agent: u32,
    pub max_idle_seconds_ephemeral: u64,
}

impl Default for SwarmLimitsConfig {
    fn default() -> Self {
        Self {
            max_spawn_depth: 3,
            max_children_per_agent: 5,
            max_agents_per_mission: 30,
            max_concurrent_agents: 12,
            max_persistent_children_per_agent: 3,
            max_turns_per_ephemeral_agent: 40,
            max_idle_seconds_ephemeral: 600,
        }
    }
}