bamboo-engine 2026.6.23

Execution engine and orchestration 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
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

use bamboo_agent_core::Session;
use bamboo_config::MemoryConfig;

use super::{AgentLoopConfig, PromptMemoryFlags};

#[test]
fn agent_loop_config_model_name_defaults_to_none() {
    let config = AgentLoopConfig::default();
    assert!(
        config.model_name.is_none(),
        "model_name should default to None, forcing explicit setting"
    );
    assert!(
        config.selected_skill_ids.is_none(),
        "selected_skill_ids should default to None"
    );
    assert!(
        config.selected_skill_mode.is_none(),
        "selected_skill_mode should default to None"
    );
    assert!(
        config.provider_type.is_none(),
        "provider_type should default to None"
    );
}

#[test]
fn agent_loop_config_can_set_model_name() {
    let config = AgentLoopConfig {
        model_name: Some("kimi-for-coding".to_string()),
        ..Default::default()
    };
    assert_eq!(config.model_name, Some("kimi-for-coding".to_string()));
}

#[test]
fn model_must_come_from_config_not_session() {
    let config = AgentLoopConfig {
        model_name: Some("config-model".to_string()),
        ..Default::default()
    };

    let session = Session::new("test", "session-model");
    let execution_model = config.model_name.as_deref().unwrap();

    assert_eq!(
        execution_model, "config-model",
        "Model must come from config.model_name, not session.model"
    );
    assert_eq!(
        session.model, "session-model",
        "session.model is just for recording, not execution"
    );
}

#[test]
fn prompt_memory_flags_map_from_memory_config() {
    let memory = MemoryConfig {
        project_prompt_injection: false,
        relevant_recall: false,
        relevant_recall_rerank: true,
        project_first_dream: false,
        ..MemoryConfig::default()
    };

    let flags = PromptMemoryFlags::from(&memory);
    assert!(!flags.project_prompt_injection);
    assert!(!flags.relevant_recall);
    assert!(flags.relevant_recall_rerank);
    assert!(!flags.project_first_dream);
}

#[test]
fn resolve_disabled_filters_uses_snapshot_without_resolver() {
    // #44 frozen behavior: with no resolver, the snapshotted sets are returned.
    let mut config = AgentLoopConfig::default();
    config.disabled_tools = std::collections::BTreeSet::from(["frozen_tool".to_string()]);
    config.disabled_skill_ids = std::collections::BTreeSet::from(["frozen_skill".to_string()]);

    let (tools, skills) = config.resolve_disabled_filters();
    assert!(tools.contains("frozen_tool"));
    assert!(skills.contains("frozen_skill"));
}

#[test]
fn resolve_disabled_filters_uses_live_resolver_and_reinvokes() {
    use std::sync::atomic::{AtomicU32, Ordering};
    use std::sync::Arc;

    // #136: a wired resolver overrides the snapshot AND is re-invoked each call,
    // so the set can change between rounds.
    let calls = Arc::new(AtomicU32::new(0));
    let c = calls.clone();
    let mut config = AgentLoopConfig::default();
    config.disabled_tools = std::collections::BTreeSet::from(["ignored_snapshot".to_string()]);
    config.disabled_filter_resolver = Some(Arc::new(move || {
        let n = c.fetch_add(1, Ordering::SeqCst);
        (
            std::collections::BTreeSet::from([format!("live-{n}")]),
            std::collections::BTreeSet::new(),
        )
    }));

    let (t1, _) = config.resolve_disabled_filters();
    assert!(t1.contains("live-0"), "resolver result is used");
    assert!(
        !t1.contains("ignored_snapshot"),
        "the resolver overrides the frozen snapshot"
    );

    let (t2, _) = config.resolve_disabled_filters();
    assert!(
        t2.contains("live-1"),
        "the resolver is re-invoked each call (live between rounds)"
    );
}