starweaver-session 0.0.4

Durable session contracts for Starweaver
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

use starweaver_core::{RunId, SessionId};

use crate::{
    approval::{ApprovalRecord, DeferredToolRecord},
    error::{SessionStoreError, SessionStoreResult},
};

use super::{run_key, run_key_label, store_failed, InMemorySessionStore};

impl InMemorySessionStore {
    pub(super) fn append_approval_record(
        &self,
        approval: ApprovalRecord,
    ) -> SessionStoreResult<()> {
        let mut inner = self.inner.lock().map_err(store_failed)?;
        let key = run_key(&approval.session_id, &approval.run_id);
        if !inner.runs.contains_key(&key) {
            return Err(SessionStoreError::NotFound(run_key_label(
                &approval.session_id,
                &approval.run_id,
            )));
        }
        let approvals = inner.approvals.entry(key).or_default();
        approvals.retain(|existing| existing.approval_id != approval.approval_id);
        approvals.push(approval);
        Ok(())
    }

    pub(super) fn load_approval_records(
        &self,
        session_id: &SessionId,
        run_id: &RunId,
    ) -> SessionStoreResult<Vec<ApprovalRecord>> {
        let inner = self.inner.lock().map_err(store_failed)?;
        Ok(inner
            .approvals
            .get(&run_key(session_id, run_id))
            .cloned()
            .unwrap_or_default())
    }

    pub(super) fn append_deferred_tool_record(
        &self,
        record: DeferredToolRecord,
    ) -> SessionStoreResult<()> {
        let mut inner = self.inner.lock().map_err(store_failed)?;
        let key = run_key(&record.session_id, &record.run_id);
        if !inner.runs.contains_key(&key) {
            return Err(SessionStoreError::NotFound(run_key_label(
                &record.session_id,
                &record.run_id,
            )));
        }
        let deferred_tools = inner.deferred_tools.entry(key).or_default();
        deferred_tools.retain(|existing| existing.deferred_id != record.deferred_id);
        deferred_tools.push(record);
        Ok(())
    }

    pub(super) fn load_deferred_tool_records(
        &self,
        session_id: &SessionId,
        run_id: &RunId,
    ) -> SessionStoreResult<Vec<DeferredToolRecord>> {
        let inner = self.inner.lock().map_err(store_failed)?;
        Ok(inner
            .deferred_tools
            .get(&run_key(session_id, run_id))
            .cloned()
            .unwrap_or_default())
    }
}