bamboo-engine 2026.6.2

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
117
118
119
120
121
122
123

use bamboo_agent_core::{Message, Role, Session};

use super::system_sections::strip_existing_prompt_block;

const GOAL_START_MARKER: &str = "<!-- BAMBOO_GOAL_START -->";
const GOAL_END_MARKER: &str = "<!-- BAMBOO_GOAL_END -->";

/// Render the goal section body that gets wrapped into the system prompt.
fn render_goal_section(goal: &str) -> String {
    format!(
        "## Session Goal\nThe user has set an explicit goal for this session. Keep working autonomously toward it until it is fully achieved. Do not stop early or hand back control while concrete progress is still possible.\n\nGoal:\n{}",
        goal.trim()
    )
}

/// Inject (or refresh) the session goal block in the system message.
///
/// When `goal` is `None`/empty, any previously injected goal block is stripped.
/// The block is wrapped in stable markers so repeated injection across rounds
/// never duplicates it, mirroring the task-list injection pattern.
pub(super) fn inject_goal_into_system_message(session: &mut Session, goal: Option<&str>) {
    let goal = goal.map(str::trim).filter(|value| !value.is_empty());

    if let Some(system_message) = session
        .messages
        .iter_mut()
        .find(|message| matches!(message.role, Role::System))
    {
        let base_prompt = strip_existing_goal(&system_message.content);

        match goal {
            Some(goal) => {
                let section = render_goal_section(goal);
                if base_prompt.trim().is_empty() {
                    system_message.content =
                        format!("{GOAL_START_MARKER}\n{section}\n{GOAL_END_MARKER}");
                } else {
                    system_message.content = format!(
                        "{}\n\n{GOAL_START_MARKER}\n{section}\n{GOAL_END_MARKER}",
                        base_prompt.trim_end(),
                    );
                }
                tracing::debug!(
                    "Injected session goal into system message ({} chars)",
                    goal.len()
                );
            }
            None => {
                system_message.content = base_prompt;
            }
        }
    } else if let Some(goal) = goal {
        let section = render_goal_section(goal);
        session.messages.insert(
            0,
            Message::system(format!("{GOAL_START_MARKER}\n{section}\n{GOAL_END_MARKER}")),
        );
        tracing::debug!(
            "Created system message with session goal ({} chars)",
            goal.len()
        );
    }
}

pub(super) fn strip_existing_goal(prompt: &str) -> String {
    strip_existing_prompt_block(prompt, GOAL_START_MARKER, GOAL_END_MARKER)
}

#[cfg(test)]
mod tests {
    use super::*;
    use bamboo_agent_core::Session;

    fn system_content(session: &Session) -> &str {
        session
            .messages
            .iter()
            .find(|m| matches!(m.role, Role::System))
            .map(|m| m.content.as_str())
            .unwrap_or("")
    }

    #[test]
    fn injects_goal_block_into_existing_system_message() {
        let mut session = Session::new("s1", "model");
        session.add_message(Message::system("Base prompt.".to_string()));

        inject_goal_into_system_message(&mut session, Some("Ship the feature"));

        let content = system_content(&session);
        assert!(content.contains("Base prompt."));
        assert!(content.contains(GOAL_START_MARKER));
        assert!(content.contains("Ship the feature"));
        assert!(content.contains(GOAL_END_MARKER));
    }

    #[test]
    fn reinjection_does_not_duplicate_goal_block() {
        let mut session = Session::new("s1", "model");
        session.add_message(Message::system("Base prompt.".to_string()));

        inject_goal_into_system_message(&mut session, Some("Goal A"));
        inject_goal_into_system_message(&mut session, Some("Goal B"));

        let content = system_content(&session);
        assert_eq!(content.matches(GOAL_START_MARKER).count(), 1);
        assert!(content.contains("Goal B"));
        assert!(!content.contains("Goal A"));
    }

    #[test]
    fn empty_goal_strips_existing_block() {
        let mut session = Session::new("s1", "model");
        session.add_message(Message::system("Base prompt.".to_string()));

        inject_goal_into_system_message(&mut session, Some("Goal A"));
        inject_goal_into_system_message(&mut session, None);

        let content = system_content(&session);
        assert!(content.contains("Base prompt."));
        assert!(!content.contains(GOAL_START_MARKER));
    }
}