1use chrono::{DateTime, Utc};
2use serde::{Deserialize, Serialize};
3use serde_json::Value;
4use uuid::Uuid;
5
6pub type UUID = Uuid;
7
8#[derive(Debug, Clone, Serialize, Deserialize)]
9pub struct ProjectDbHandle {
10 pub org_id: Uuid,
11 pub project_id: Uuid,
12 pub connection_url: String,
13 #[serde(default)]
14 pub auth_token: Option<String>,
15}
16
17#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(rename_all = "snake_case")]
19pub enum EventDirection {
20 Inbound,
21 Outbound,
22}
23
24#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(rename_all = "snake_case")]
26pub enum EventStatus {
27 Pending,
28 Processing,
29 Succeeded,
30 Failed,
31}
32
33#[derive(Debug, Clone, Serialize, Deserialize)]
34pub struct Event {
35 pub event_id: String,
36 pub org_id: String,
37 #[serde(default)]
38 pub project_id: Option<String>,
39 pub topic: String,
40 pub source: String,
41 pub direction: EventDirection,
42 pub payload: Value,
43 pub dedupe_key: String,
44 #[serde(default)]
45 pub metadata: std::collections::HashMap<String, Value>,
46 pub status: EventStatus,
47 pub created_at: DateTime<Utc>,
48}
49
50#[derive(Debug, Clone, Serialize, Deserialize)]
51#[serde(rename_all = "snake_case")]
52pub enum SubscriptionHandlerType {
53 Webhook,
54 InternalQueue,
55}
56
57#[derive(Debug, Clone, Serialize, Deserialize)]
58pub struct SubscriptionHandler {
59 #[serde(rename = "type")]
60 pub handler_type: SubscriptionHandlerType,
61 #[serde(default)]
62 pub url: Option<String>,
63 #[serde(default)]
64 pub queue_name: Option<String>,
65}
66
67#[derive(Debug, Clone, Serialize, Deserialize)]
68pub struct SubscriptionConfig {
69 #[serde(default = "default_max_attempts")]
70 pub max_attempts: i64,
71 #[serde(default = "default_backoff_ms")]
72 pub backoff_ms: i64,
73}
74
75fn default_max_attempts() -> i64 {
76 3
77}
78fn default_backoff_ms() -> i64 {
79 1000
80}
81
82#[derive(Debug, Clone, Serialize, Deserialize)]
83pub struct Subscription {
84 pub subscription_id: String,
85 pub org_id: String,
86 pub topic_pattern: String,
87 pub direction: EventDirection,
88 pub handler: SubscriptionHandler,
89 pub config: SubscriptionConfig,
90 #[serde(default)]
91 pub filter: Option<std::collections::HashMap<String, Value>>,
92}
93
94#[derive(Debug, Clone, Serialize, Deserialize)]
95pub struct AgentRunResult {
96 pub run_id: Uuid,
97 pub org_id: Uuid,
98 pub project_id: Uuid,
99 pub agent_id: String,
100 pub started_at: DateTime<Utc>,
101 pub finished_at: DateTime<Utc>,
102 #[serde(default)]
103 pub proposed_action_ids: Vec<Uuid>,
104}
105
106#[derive(Debug, Clone, Serialize, Deserialize)]
107#[serde(rename_all = "snake_case")]
108pub enum RiskLevel {
109 Low,
110 Medium,
111 High,
112 Critical,
113}
114
115#[derive(Debug, Clone, Serialize, Deserialize)]
116#[serde(rename_all = "snake_case")]
117pub enum ActionStatus {
118 Proposed,
119 Approved,
120 Denied,
121 Executed,
122 Expired,
123}
124
125#[derive(Debug, Clone, Serialize, Deserialize)]
126pub struct ActionProposal {
127 pub id: Uuid,
128 pub org_id: Uuid,
129 pub project_id: Uuid,
130 pub agent_id: String,
131 pub action_type: String,
132 pub payload: Value,
133 pub risk_level: RiskLevel,
134 #[serde(default)]
135 pub dedupe_key: Option<String>,
136 pub context: Value,
137 pub status: ActionStatus,
138 pub created_at: DateTime<Utc>,
139 #[serde(default)]
140 pub decided_at: Option<DateTime<Utc>>,
141 #[serde(default)]
142 pub decided_by: Option<String>,
143 #[serde(default)]
144 pub decision_reason: Option<String>,
145 pub expires_at: DateTime<Utc>,
146 #[serde(default)]
147 pub execution_result: Option<Value>,
148}
149
150#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(rename_all = "snake_case")]
152pub enum StepStatus {
153 Queued,
154 Running,
155 Succeeded,
156 Failed,
157 Skipped,
158}
159
160#[derive(Debug, Clone, Serialize, Deserialize)]
161pub struct StepResult {
162 pub step_id: String,
163 pub status: StepStatus,
164 #[serde(default)]
165 pub output: Option<Value>,
166 #[serde(default)]
167 pub error: Option<String>,
168 pub duration_ms: i64,
169}
170
171#[derive(Debug, Clone, Serialize, Deserialize)]
172pub struct PipelineRun {
173 pub id: String,
174 pub pipeline_id: String,
175 pub status: Value,
176 pub step_results: std::collections::HashMap<String, StepResult>,
177 pub started_at: DateTime<Utc>,
178 #[serde(default)]
179 pub completed_at: Option<DateTime<Utc>>,
180}
181
182#[derive(Debug, Clone, Serialize, Deserialize)]
183#[serde(rename_all = "snake_case")]
184pub enum MemoryType {
185 Observation,
186 Summary,
187 Action,
188}
189
190#[derive(Debug, Clone, Serialize, Deserialize)]
191pub struct MemoryItem {
192 #[serde(default)]
193 pub id: Option<String>,
194 pub scope: std::collections::HashMap<String, String>,
195 pub item_type: MemoryType,
196 pub content: Value,
197 #[serde(default)]
198 pub index_text: Option<String>,
199 #[serde(default)]
200 pub importance_0_to_1: Option<f64>,
201 pub created_at: DateTime<Utc>,
202}
203
204#[derive(Debug, Clone, Serialize, Deserialize)]
205pub struct Summary {
206 pub agent_id: String,
207 pub horizon: String,
208 pub content: Value,
209 pub at: DateTime<Utc>,
210}
211
212#[derive(Debug, Clone, Serialize, Deserialize)]
213pub struct OptimizationRunRow {
214 pub run_id: Uuid,
215 pub org_id: Uuid,
216 pub project_id: Uuid,
217 pub status: String,
218 pub started_at: DateTime<Utc>,
219 #[serde(default)]
220 pub finished_at: Option<DateTime<Utc>>,
221 pub cfg: std::collections::HashMap<String, Value>,
222 pub initial_policy: std::collections::HashMap<String, Value>,
223}
224
225#[derive(Debug, Clone, Serialize, Deserialize)]
226pub struct EvalReportRow {
227 pub report_id: Uuid,
228 pub org_id: Uuid,
229 pub project_id: Uuid,
230 pub status: String,
231 pub created_at: DateTime<Utc>,
232 #[serde(default)]
233 pub completed_at: Option<DateTime<Utc>>,
234 pub case: std::collections::HashMap<String, Value>,
235}
236
237#[derive(Debug, Clone, Serialize, Deserialize)]
238pub struct Health {
239 pub status: String,
240 pub uptime_ms: i64,
241}
242