bamboo-server 2026.4.28

HTTP server and API layer for the Bamboo agent framework
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

//! Session loading helpers for the respond handler.
//!
//! The main `load_session_from_memory_or_storage` has been migrated to
//! `AppState::load_session_merged` in `crate::app_state::session_loader`.

#[cfg(test)]
mod tests {
    use crate::app_state::AppState;
    use actix_web::web;
    use bamboo_agent_core::Session;

    #[tokio::test]
    async fn prefers_storage_when_memory_lacks_pending_question() {
        let temp_dir = tempfile::tempdir().expect("temp dir");
        let state = AppState::new(temp_dir.path().to_path_buf())
            .await
            .expect("app state should initialize");
        let state = web::Data::new(state);

        let session_id = "session-stale-memory";
        let memory_session = Session::new(session_id, "test-model");
        let mut storage_session = memory_session.clone();
        storage_session.set_pending_question(
            "tool-call-1".to_string(),
            "Need confirmation?".to_string(),
            vec!["OK".to_string()],
            true,
        );

        {
            let mut sessions = state.sessions.write().await;
            sessions.insert(session_id.to_string(), memory_session);
        }
        state
            .storage
            .save_session(&storage_session)
            .await
            .expect("storage save should succeed");

        let loaded = state
            .load_session_merged(session_id)
            .await
            .expect("session should load");

        assert!(loaded.pending_question.is_some());
        assert_eq!(
            loaded
                .pending_question
                .as_ref()
                .map(|pending| pending.tool_call_id.as_str()),
            Some("tool-call-1")
        );

        let cached = {
            let sessions = state.sessions.read().await;
            sessions
                .get(session_id)
                .cloned()
                .expect("cache should be warmed")
        };
        assert!(cached.pending_question.is_some());
    }
}