1use serde::{Deserialize, Serialize};
11
12use crate::event::SourceTier;
13use crate::intent::{ActionType, DecisionRoute, DenialReason, SuggestedAction};
14
15#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
21pub struct ActionCoord {
22 pub window_ordinal: u32,
23 pub intent_ordinal: u32,
24 pub action_ordinal: u32,
25}
26
27#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
29pub enum EffectClass {
30 PureRead,
32 LocalCacheWrite,
34 LocalStateChange,
36}
37
38impl EffectClass {
39 pub fn from_action_type(action_type: &ActionType) -> Self {
41 match action_type {
42 ActionType::NoOp => Self::PureRead,
43 ActionType::PrefetchFile => Self::LocalCacheWrite,
44 ActionType::PreWarmProcess | ActionType::KeepAlive | ActionType::ReleaseMemory => {
45 Self::LocalStateChange
46 },
47 }
48 }
49}
50
51#[derive(Debug, Clone, Serialize, Deserialize)]
56pub struct ActionProposal {
57 pub intent_id: String,
59 pub coord: ActionCoord,
61 pub action: SuggestedAction,
63 pub effect: EffectClass,
65 pub proposed_at_ms: i64,
67}
68
69#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
73pub enum ActionState {
74 Proposed,
76 SchemaValidated,
77 PolicyChecked,
78 Dispatched,
79 Succeeded,
81 RejectedInvalidSchema,
84 DeniedByCapability,
87 DeniedByPolicy,
89 Failed,
91}
92
93impl ActionState {
94 pub fn is_terminal(self) -> bool {
96 matches!(
97 self,
98 Self::Succeeded
99 | Self::RejectedInvalidSchema
100 | Self::DeniedByCapability
101 | Self::DeniedByPolicy
102 | Self::Failed
103 )
104 }
105}
106
107#[derive(Debug, Clone, Serialize, Deserialize)]
113pub struct ActionOutcome {
114 pub action_type: String,
115 pub target: Option<String>,
116 pub summary: String,
117 pub latency_us: u64,
118}
119
120#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
122pub struct ActionOutcomeSummary {
123 pub action_type: String,
124 pub target: Option<String>,
125 pub summary: String,
126}
127
128impl ActionOutcomeSummary {
129 pub fn from_outcome(outcome: &ActionOutcome) -> Self {
131 Self {
132 action_type: outcome.action_type.clone(),
133 target: outcome.target.clone(),
134 summary: outcome.summary.clone(),
135 }
136 }
137}
138
139#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, thiserror::Error)]
144pub enum AdapterError {
145 #[error("simulated resource unavailable: {0}")]
146 SimulatedResourceUnavailable(String),
147 #[error("android bridge error: {0}")]
148 AndroidBridgeError(String),
149 #[error("execution error: {0}")]
150 ExecutionError(String),
151}
152
153#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
155pub enum PolicyVerdict {
156 Approved,
157 Denied(DenialReason),
158}
159
160#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
162pub struct PolicyActionDecision {
163 pub intent_ordinal: u32,
164 pub action_ordinal: u32,
165 pub verdict: PolicyVerdict,
166}
167
168#[derive(Debug, Clone, Serialize, Deserialize)]
172pub struct AuditRecord {
173 pub coord: ActionCoord,
175 pub intent_id: String,
177 pub action_type: ActionType,
178 pub target: Option<String>,
179 pub effect: EffectClass,
180 pub route: DecisionRoute,
182 pub backend_error: Option<String>,
184 pub transitions: Vec<ActionState>,
186 pub terminal: ActionState,
188 pub outcome: Option<ActionOutcomeSummary>,
190 pub denial_reason: Option<DenialReason>,
192 pub error: Option<String>,
194 pub source_tier: SourceTier,
197}
198
199impl AuditRecord {
200 pub fn new(proposal: &ActionProposal, route: DecisionRoute, source_tier: SourceTier) -> Self {
202 Self {
203 coord: proposal.coord,
204 intent_id: proposal.intent_id.clone(),
205 action_type: proposal.action.action_type.clone(),
206 target: proposal.action.target.clone(),
207 effect: proposal.effect,
208 route,
209 backend_error: None,
210 transitions: vec![ActionState::Proposed],
211 terminal: ActionState::Proposed,
212 outcome: None,
213 denial_reason: None,
214 error: None,
215 source_tier,
216 }
217 }
218
219 pub fn transition(&mut self, state: ActionState) {
221 self.transitions.push(state);
222 self.terminal = state;
223 }
224}
225
226#[cfg(test)]
227mod tests {
228 use super::*;
229
230 #[test]
231 fn action_state_terminal_detection() {
232 assert!(!ActionState::Proposed.is_terminal());
233 assert!(!ActionState::SchemaValidated.is_terminal());
234 assert!(!ActionState::PolicyChecked.is_terminal());
235 assert!(!ActionState::Dispatched.is_terminal());
236 assert!(ActionState::Succeeded.is_terminal());
237 assert!(ActionState::RejectedInvalidSchema.is_terminal());
238 assert!(ActionState::DeniedByCapability.is_terminal());
239 assert!(ActionState::DeniedByPolicy.is_terminal());
240 assert!(ActionState::Failed.is_terminal());
241 }
242
243 #[test]
244 fn effect_class_derived_from_action_type() {
245 assert_eq!(
246 EffectClass::from_action_type(&ActionType::NoOp),
247 EffectClass::PureRead
248 );
249 assert_eq!(
250 EffectClass::from_action_type(&ActionType::PrefetchFile),
251 EffectClass::LocalCacheWrite
252 );
253 assert_eq!(
254 EffectClass::from_action_type(&ActionType::PreWarmProcess),
255 EffectClass::LocalStateChange
256 );
257 assert_eq!(
258 EffectClass::from_action_type(&ActionType::KeepAlive),
259 EffectClass::LocalStateChange
260 );
261 assert_eq!(
262 EffectClass::from_action_type(&ActionType::ReleaseMemory),
263 EffectClass::LocalStateChange
264 );
265 }
266}