tandem-server 0.6.8

HTTP server for Tandem engine APIs
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

// Tests for the fail-close attribution rule in event memory ingestion
// (TAN-633): events that cannot be attributed to a session's run context must
// not be persisted at all, instead of being filed under a fabricated
// user_id="default" + default tenant scope.
#[cfg(test)]
mod event_ingestion_fail_close_tests {
    use super::*;
    use std::collections::HashMap;

    fn permission_event(session_id: &str) -> EngineEvent {
        EngineEvent {
            event_type: "permission.asked".to_string(),
            properties: json!({
                "sessionID": session_id,
                "tool": "bash",
                "query": "run the test suite",
            }),
            envelope: None,
        }
    }

    fn permission_reply_event(session_id: &str) -> EngineEvent {
        EngineEvent {
            event_type: "permission.replied".to_string(),
            properties: json!({
                "sessionID": session_id,
                "requestID": "perm-1",
                "reply": "allow",
            }),
            envelope: None,
        }
    }

    #[tokio::test]
    async fn event_without_run_context_is_dropped() {
        let state = crate::test_support::test_state().await;
        let db = MemoryDatabase::new(&state.memory_db_path)
            .await
            .expect("open memory db");

        ingest_event_memory_records(
            &state,
            &db,
            &permission_event("sess-unattributed"),
            &HashMap::new(),
        )
        .await;

        let records = db
            .list_global_memory("default", None, None, None, 50, 0)
            .await
            .expect("list records");
        assert!(
            records.is_empty(),
            "unattributable event must not persist memory: {records:?}"
        );
    }

    #[tokio::test]
    async fn event_with_run_context_persists_under_resolved_subject() {
        let state = crate::test_support::test_state().await;
        let db = MemoryDatabase::new(&state.memory_db_path)
            .await
            .expect("open memory db");

        let mut ctx_by_session = HashMap::new();
        ctx_by_session.insert(
            "sess-attributed".to_string(),
            RunMemoryContext {
                run_id: "run-1".to_string(),
                user_id: "user-42".to_string(),
                started_at_ms: 0,
                host_tag: None,
                tenant_context: TenantContext::default(),
                owner_org_unit_id: None,
            },
        );

        ingest_event_memory_records(
            &state,
            &db,
            &permission_event("sess-attributed"),
            &ctx_by_session,
        )
        .await;

        let records = db
            .list_global_memory("user-42", None, None, None, 50, 0)
            .await
            .expect("list records");
        assert_eq!(records.len(), 1, "attributed event should persist once");
        assert_eq!(records[0].user_id, "user-42");
        assert_eq!(records[0].source_type, "approval_request");

        let default_records = db
            .list_global_memory("default", None, None, None, 50, 0)
            .await
            .expect("list default records");
        assert!(
            default_records.is_empty(),
            "nothing may fall through to the catch-all subject"
        );
    }

    #[tokio::test]
    async fn permission_reply_with_run_context_persists_approval_decision() {
        let state = crate::test_support::test_state().await;
        let db = MemoryDatabase::new(&state.memory_db_path)
            .await
            .expect("open memory db");

        let mut ctx_by_session = HashMap::new();
        ctx_by_session.insert(
            "sess-reply".to_string(),
            RunMemoryContext {
                run_id: "run-reply".to_string(),
                user_id: "user-reply".to_string(),
                started_at_ms: 0,
                host_tag: None,
                tenant_context: TenantContext::default(),
                owner_org_unit_id: None,
            },
        );

        ingest_event_memory_records(
            &state,
            &db,
            &permission_reply_event("sess-reply"),
            &ctx_by_session,
        )
        .await;

        let records = db
            .list_global_memory("user-reply", None, None, None, 50, 0)
            .await
            .expect("list records");
        assert_eq!(
            records.len(),
            1,
            "attributed permission replies should persist once"
        );
        assert_eq!(records[0].source_type, "approval_decision");
        assert_eq!(records[0].session_id.as_deref(), Some("sess-reply"));
        assert_eq!(records[0].run_id, "run-reply");
    }
}