symbi_runtime/types/
agent.rs

1//! Agent-related types and data structures
2
3use serde::{Deserialize, Serialize};
4use std::collections::HashMap;
5use std::time::{Duration, SystemTime};
6
7use super::{AgentId, Capability, Dependency, PolicyId, Priority};
8use crate::types::resource::{ResourceAllocation, ResourceLimits};
9use crate::types::security::SecurityTier;
10
11/// Agent configuration for initialization
12#[derive(Debug, Clone, Serialize, Deserialize)]
13pub struct AgentConfig {
14    pub id: AgentId,
15    pub name: String,
16    pub dsl_source: String,
17    pub execution_mode: ExecutionMode,
18    pub security_tier: SecurityTier,
19    pub resource_limits: ResourceLimits,
20    pub capabilities: Vec<Capability>,
21    pub policies: Vec<PolicyId>,
22    pub metadata: HashMap<String, String>,
23    pub priority: Priority,
24}
25
26/// Agent execution modes
27#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
28pub enum ExecutionMode {
29    /// Long-lived agent that persists across tasks
30    Persistent,
31    /// Task-based execution that terminates after completion
32    #[default]
33    Ephemeral,
34    /// Interval-based scheduling with periodic execution
35    Scheduled { interval: Duration },
36    /// Cron-expression–based scheduling with timezone support
37    CronScheduled {
38        cron_expression: String,
39        timezone: String,
40    },
41    /// Reactive to events and messages
42    EventDriven,
43    /// Externally-managed agent visible for fleet monitoring only.
44    /// Not scheduled or executed by the runtime.
45    External {
46        /// Optional HTTP endpoint for the agent (future health check pull).
47        endpoint: Option<String>,
48        /// Optional AgentPin domain for identity verification (A2A forward-compat).
49        agentpin_domain: Option<String>,
50        /// Expected heartbeat interval in seconds. Default 60. Unreachable after 3×.
51        heartbeat_interval_secs: u64,
52    },
53}
54
55/// Agent state in the lifecycle
56#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Hash, Default)]
57pub enum AgentState {
58    #[default]
59    Created,
60    Initializing,
61    Ready,
62    Running,
63    Suspended,
64    Waiting,
65    Completed,
66    Failed,
67    Terminating,
68    Terminated,
69    /// External agent has not sent a heartbeat within the expected window.
70    Unreachable,
71}
72
73/// Agent metadata structure
74#[derive(Debug, Clone, Serialize, Deserialize)]
75pub struct AgentMetadata {
76    pub version: String,
77    pub author: String,
78    pub description: String,
79    pub capabilities: Vec<Capability>,
80    pub dependencies: Vec<Dependency>,
81    pub resource_requirements: ResourceRequirements,
82    pub security_requirements: SecurityRequirements,
83    pub custom_fields: HashMap<String, String>,
84}
85
86/// Resource requirements for an agent
87#[derive(Debug, Clone, Serialize, Deserialize)]
88pub struct ResourceRequirements {
89    pub min_memory_mb: usize,
90    pub max_memory_mb: usize,
91    pub min_cpu_cores: f32,
92    pub max_cpu_cores: f32,
93    pub disk_space_mb: usize,
94    pub network_bandwidth_mbps: usize,
95}
96
97impl Default for ResourceRequirements {
98    fn default() -> Self {
99        Self {
100            min_memory_mb: 64,
101            max_memory_mb: 512,
102            min_cpu_cores: 0.1,
103            max_cpu_cores: 1.0,
104            disk_space_mb: 100,
105            network_bandwidth_mbps: 10,
106        }
107    }
108}
109
110/// Security requirements for an agent
111#[derive(Debug, Clone, Serialize, Deserialize)]
112pub struct SecurityRequirements {
113    pub min_security_tier: SecurityTier,
114    pub requires_encryption: bool,
115    pub requires_signature: bool,
116    pub network_isolation: bool,
117    pub file_system_isolation: bool,
118}
119
120impl Default for SecurityRequirements {
121    fn default() -> Self {
122        Self {
123            min_security_tier: SecurityTier::Tier1,
124            requires_encryption: true,
125            requires_signature: true,
126            network_isolation: true,
127            file_system_isolation: true,
128        }
129    }
130}
131
132/// Runtime instance of an agent
133#[derive(Debug, Clone)]
134pub struct AgentInstance {
135    pub id: AgentId,
136    pub config: AgentConfig,
137    pub state: AgentState,
138    pub resource_allocation: Option<ResourceAllocation>,
139    pub sandbox_handle: Option<SandboxHandle>,
140    pub created_at: SystemTime,
141    pub last_activity: SystemTime,
142    pub execution_count: u64,
143    pub last_state_change: SystemTime,
144    pub error_count: u32,
145    pub restart_count: u32,
146    pub last_error: Option<String>,
147}
148
149impl AgentInstance {
150    pub fn new(config: AgentConfig) -> Self {
151        let now = SystemTime::now();
152        Self {
153            id: config.id,
154            config,
155            state: AgentState::Created,
156            resource_allocation: None,
157            sandbox_handle: None,
158            created_at: now,
159            last_activity: now,
160            execution_count: 0,
161            last_state_change: now,
162            error_count: 0,
163            restart_count: 0,
164            last_error: None,
165        }
166    }
167
168    pub fn update_activity(&mut self) {
169        self.last_activity = SystemTime::now();
170    }
171
172    pub fn increment_execution(&mut self) {
173        self.execution_count += 1;
174        self.update_activity();
175    }
176}
177
178/// Handle to a sandbox environment
179#[derive(Debug, Clone, Serialize, Deserialize)]
180pub struct SandboxHandle {
181    pub id: String,
182    pub security_tier: SecurityTier,
183    pub created_at: SystemTime,
184    pub process_id: Option<u32>,
185    pub container_id: Option<String>,
186}
187
188/// Reasons for agent termination
189#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
190pub enum TerminationReason {
191    Completed,
192    Failed(String),
193    PolicyViolation(String),
194    ResourceExhaustion,
195    Timeout,
196    ManualTermination,
197    SystemShutdown,
198}
199
200impl std::fmt::Display for TerminationReason {
201    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
202        match self {
203            TerminationReason::Completed => write!(f, "Completed successfully"),
204            TerminationReason::Failed(reason) => write!(f, "Failed: {}", reason),
205            TerminationReason::PolicyViolation(policy) => write!(f, "Policy violation: {}", policy),
206            TerminationReason::ResourceExhaustion => write!(f, "Resource exhaustion"),
207            TerminationReason::Timeout => write!(f, "Execution timeout"),
208            TerminationReason::ManualTermination => write!(f, "Manual termination"),
209            TerminationReason::SystemShutdown => write!(f, "System shutdown"),
210        }
211    }
212}
symbi_runtime/types/agent.rs

symbi_runtime/types/
agent.rs
