agent_workspace_contract/environment/
resources.rs

1use super::*;
2
3// Product response DTOs. Provider references (external ids), credential hashes
4// and provider revisions stay off this plane. The provider name is public
5// resource identity and is included so callers can tell moulin from e2b.
6
7#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
8#[serde(deny_unknown_fields, rename_all = "camelCase")]
9pub struct SpaceGrantResource {
10    pub id: String,
11    pub space_id: String,
12    pub principal: PrincipalRef,
13    pub capabilities: BTreeSet<SpaceCapability>,
14    pub path_prefixes: Vec<String>,
15    pub expires_at_ms: Option<u64>,
16    pub active: bool,
17    pub version: u64,
18}
19
20impl From<SpaceGrant> for SpaceGrantResource {
21    fn from(record: SpaceGrant) -> Self {
22        Self {
23            id: record.id,
24            space_id: record.space_id,
25            principal: record.principal,
26            capabilities: record.capabilities,
27            path_prefixes: record.path_prefixes,
28            expires_at_ms: record.expires_at_ms,
29            active: record.active,
30            version: record.version,
31        }
32    }
33}
34
35#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
36#[serde(deny_unknown_fields, rename_all = "camelCase")]
37pub struct SpaceCollaborationSessionResource {
38    pub id: String,
39    pub space_id: String,
40    pub principal: PrincipalRef,
41    pub delegation_id: Option<String>,
42    pub requested_mode: SpaceAccessMode,
43    pub effective_mode: SpaceAccessMode,
44    pub lifecycle: SpaceSessionLifecycle,
45    pub last_heartbeat_at_ms: u64,
46    pub expires_at_ms: u64,
47    pub version: u64,
48}
49
50impl From<SpaceCollaborationSession> for SpaceCollaborationSessionResource {
51    fn from(record: SpaceCollaborationSession) -> Self {
52        Self {
53            id: record.id,
54            space_id: record.space_id,
55            principal: record.principal,
56            delegation_id: record.delegation_id,
57            requested_mode: record.requested_mode,
58            effective_mode: record.effective_mode,
59            lifecycle: record.lifecycle,
60            last_heartbeat_at_ms: record.last_heartbeat_at_ms,
61            expires_at_ms: record.expires_at_ms,
62            version: record.version,
63        }
64    }
65}
66
67#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
68#[serde(deny_unknown_fields, rename_all = "camelCase")]
69pub struct SpaceWriteLeaseResource {
70    pub id: String,
71    pub space_id: String,
72    pub session_id: String,
73    pub fencing_token: u64,
74    pub version: u64,
75    pub acquired_at_ms: u64,
76    pub expires_at_ms: u64,
77    pub active: bool,
78}
79
80impl From<SpaceWriteLease> for SpaceWriteLeaseResource {
81    fn from(record: SpaceWriteLease) -> Self {
82        Self {
83            id: record.id,
84            space_id: record.space_id,
85            session_id: record.session_id,
86            fencing_token: record.fencing_token,
87            version: record.version,
88            acquired_at_ms: record.acquired_at_ms,
89            expires_at_ms: record.expires_at_ms,
90            active: record.active,
91        }
92    }
93}
94
95#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
96#[serde(deny_unknown_fields, rename_all = "camelCase")]
97pub struct DelegationResource {
98    pub id: String,
99    pub grantor_user_id: String,
100    pub delegate_agent_id: String,
101    pub computer_ids: BTreeSet<String>,
102    pub space_ids: BTreeSet<String>,
103    pub capabilities: BTreeSet<SpaceCapability>,
104    pub path_prefixes: Vec<String>,
105    pub purpose: String,
106    pub expires_at_ms: u64,
107    pub revoked_at_ms: Option<u64>,
108}
109
110impl From<DelegationRecord> for DelegationResource {
111    fn from(record: DelegationRecord) -> Self {
112        Self {
113            id: record.id,
114            grantor_user_id: record.grantor_user_id,
115            delegate_agent_id: record.delegate_agent_id,
116            computer_ids: record.computer_ids,
117            space_ids: record.space_ids,
118            capabilities: record.capabilities,
119            path_prefixes: record.path_prefixes,
120            purpose: record.purpose,
121            expires_at_ms: record.expires_at_ms,
122            revoked_at_ms: record.revoked_at_ms,
123        }
124    }
125}
126
127#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
128#[serde(deny_unknown_fields, rename_all = "camelCase")]
129pub struct ComputerResource {
130    pub id: String,
131    pub provider: String,
132    pub lifecycle: ComputerLifecycle,
133    pub capabilities: ProviderCapabilities,
134    pub owners: Vec<OwnerRef>,
135    pub version: u64,
136    pub created_at_ms: u64,
137    pub updated_at_ms: u64,
138}
139
140impl From<ComputerRecord> for ComputerResource {
141    fn from(record: ComputerRecord) -> Self {
142        Self {
143            id: record.id,
144            provider: record.provider_ref.provider,
145            lifecycle: record.lifecycle,
146            capabilities: record.capabilities,
147            owners: record.owners,
148            version: record.version,
149            created_at_ms: record.created_at_ms,
150            updated_at_ms: record.updated_at_ms,
151        }
152    }
153}
154
155#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
156#[serde(deny_unknown_fields, rename_all = "camelCase")]
157pub struct SpaceResource {
158    pub id: String,
159    pub computer_id: String,
160    #[serde(default)]
161    pub provider: String,
162    pub persistence: SpacePersistence,
163    pub lifecycle: SpaceLifecycle,
164    pub capabilities: ProviderCapabilities,
165    pub owners: Vec<OwnerRef>,
166    pub source_snapshot_id: Option<String>,
167    pub revision: u64,
168    pub version: u64,
169    pub created_at_ms: u64,
170    pub updated_at_ms: u64,
171}
172
173impl SpaceResource {
174    pub fn from_record(record: SpaceRecord, provider: impl Into<String>) -> Self {
175        Self {
176            id: record.id,
177            computer_id: record.computer_id,
178            provider: provider.into(),
179            persistence: record.persistence,
180            lifecycle: record.lifecycle,
181            capabilities: record.capabilities,
182            owners: record.owners,
183            source_snapshot_id: record.source_snapshot_id,
184            revision: record.revision,
185            version: record.version,
186            created_at_ms: record.created_at_ms,
187            updated_at_ms: record.updated_at_ms,
188        }
189    }
190}
191
192#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
193#[serde(deny_unknown_fields, rename_all = "camelCase")]
194pub struct SandboxResource {
195    pub id: String,
196    pub placement: SandboxPlacement,
197    pub lifecycle: SandboxLifecycle,
198    pub owners: Vec<OwnerRef>,
199    pub capabilities: ProviderCapabilities,
200    pub mounts: Vec<SandboxMountRecord>,
201    pub expires_at_ms: u64,
202    pub version: u64,
203    pub created_at_ms: u64,
204    pub updated_at_ms: u64,
205}
206
207impl From<SandboxRecord> for SandboxResource {
208    fn from(record: SandboxRecord) -> Self {
209        Self {
210            id: record.id,
211            placement: record.placement,
212            lifecycle: record.lifecycle,
213            owners: record.owners,
214            capabilities: record.capabilities,
215            mounts: record.mounts,
216            expires_at_ms: record.expires_at_ms,
217            version: record.version,
218            created_at_ms: record.created_at_ms,
219            updated_at_ms: record.updated_at_ms,
220        }
221    }
222}
223
224#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
225#[serde(deny_unknown_fields, rename_all = "camelCase")]
226pub struct SnapshotResource {
227    pub id: String,
228    pub provider: String,
229    pub visibility: SnapshotVisibility,
230    pub owners: Vec<OwnerRef>,
231    pub builtin: bool,
232    pub created_by: PrincipalRef,
233    pub lifecycle: SnapshotLifecycle,
234    pub digest: Option<String>,
235    pub size_bytes: Option<u64>,
236    pub error: Option<String>,
237    pub created_at_ms: u64,
238}
239
240impl From<SnapshotRecord> for SnapshotResource {
241    fn from(record: SnapshotRecord) -> Self {
242        Self {
243            id: record.id,
244            provider: record.provider,
245            visibility: record.visibility,
246            owners: record.owners,
247            builtin: record.builtin,
248            created_by: record.created_by,
249            lifecycle: record.lifecycle,
250            digest: record.digest,
251            size_bytes: record.size_bytes,
252            error: record.error,
253            created_at_ms: record.created_at_ms,
254        }
255    }
256}
257
258#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
259#[serde(deny_unknown_fields, rename_all = "camelCase")]
260pub struct TemplateVersionResource {
261    pub template_id: String,
262    pub version: String,
263    pub provider: String,
264    pub created_by: PrincipalRef,
265    pub target: TemplateTarget,
266    pub base_snapshot_id: Option<String>,
267    pub resource_profile: BTreeMap<String, String>,
268    pub parameter_schema: BTreeMap<String, String>,
269    pub state: TemplateVersionState,
270    pub created_at_ms: u64,
271}
272
273impl From<TemplateVersionRecord> for TemplateVersionResource {
274    fn from(record: TemplateVersionRecord) -> Self {
275        Self {
276            template_id: record.template_id,
277            version: record.version,
278            provider: record.provider,
279            created_by: record.created_by,
280            target: record.target,
281            base_snapshot_id: record.base_snapshot_id,
282            resource_profile: record.resource_profile,
283            parameter_schema: record.parameter_schema,
284            state: record.state,
285            created_at_ms: record.created_at_ms,
286        }
287    }
288}
289
290#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
291#[serde(deny_unknown_fields, rename_all = "camelCase")]
292pub struct SpaceChangeSetResource {
293    pub id: String,
294    pub source_space_id: String,
295    pub target_space_id: String,
296    pub base_revision: u64,
297    pub created_by_session_id: String,
298    pub lifecycle: ChangeSetLifecycle,
299    pub created_at_ms: u64,
300}
301
302impl From<SpaceChangeSetRecord> for SpaceChangeSetResource {
303    fn from(record: SpaceChangeSetRecord) -> Self {
304        Self {
305            id: record.id,
306            source_space_id: record.source_space_id,
307            target_space_id: record.target_space_id,
308            base_revision: record.base_revision,
309            created_by_session_id: record.created_by_session_id,
310            lifecycle: record.lifecycle,
311            created_at_ms: record.created_at_ms,
312        }
313    }
314}
315
316#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
317#[serde(deny_unknown_fields, rename_all = "camelCase")]
318pub struct SpaceAccessTicketResource {
319    pub id: String,
320    pub space_id: String,
321    pub session_id: String,
322    pub mode: SpaceAccessMode,
323    pub capability_paths: BTreeMap<SpaceCapability, Vec<String>>,
324    pub fencing_token: Option<u64>,
325    pub expires_at_ms: u64,
326}
327
328#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
329#[serde(deny_unknown_fields, rename_all = "camelCase")]
330pub struct IssuedSpaceAccessTicketResource {
331    pub ticket: SpaceAccessTicketResource,
332    pub token: String,
333}
334
335impl From<IssuedSpaceAccessTicket> for IssuedSpaceAccessTicketResource {
336    fn from(issued: IssuedSpaceAccessTicket) -> Self {
337        Self {
338            ticket: SpaceAccessTicketResource {
339                id: issued.ticket.id,
340                space_id: issued.ticket.space_id,
341                session_id: issued.ticket.session_id,
342                mode: issued.ticket.mode,
343                capability_paths: issued.ticket.capability_paths,
344                fencing_token: issued.ticket.fencing_token,
345                expires_at_ms: issued.ticket.expires_at_ms,
346            },
347            token: issued.token,
348        }
349    }
350}
351
352#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
353#[serde(deny_unknown_fields, rename_all = "camelCase")]
354pub struct SpaceFileContent {
355    #[serde(with = "super::base64_bytes")]
356    pub bytes: Vec<u8>,
357}
358
359#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
360#[serde(deny_unknown_fields, rename_all = "camelCase")]
361pub struct SpaceFileEntry {
362    pub path: String,
363    pub is_dir: bool,
364    #[serde(default, skip_serializing_if = "Option::is_none")]
365    pub size_bytes: Option<u64>,
366}
367
368impl From<ProviderFileEntry> for SpaceFileEntry {
369    fn from(entry: ProviderFileEntry) -> Self {
370        Self {
371            path: entry.path,
372            is_dir: entry.is_dir,
373            size_bytes: entry.size_bytes,
374        }
375    }
376}
377
378impl From<ProviderFileContent> for SpaceFileContent {
379    fn from(content: ProviderFileContent) -> Self {
380        Self {
381            bytes: content.bytes,
382        }
383    }
384}
agent_workspace_contract/environment/resources.rs

agent_workspace_contract/environment/
resources.rs
