bamboo-engine 2026.4.30

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

use std::sync::Arc;

use bamboo_agent_core::tools::ToolExecutor;
use bamboo_agent_core::Role;
use bamboo_agent_core::Session;
use bamboo_tools::exposure::activated_discoverable_tools;

use crate::runtime::config::AgentLoopConfig;
use crate::runtime::managers::prompt::{PromptAssemblyOutput, PromptManager};

/// Default prompt manager that delegates to existing runner functions.
pub struct DefaultPromptManager {
    tools: Arc<dyn ToolExecutor>,
}

impl DefaultPromptManager {
    pub fn new(tools: Arc<dyn bamboo_agent_core::tools::ToolExecutor>) -> Self {
        Self { tools }
    }
}

#[async_trait::async_trait]
impl PromptManager for DefaultPromptManager {
    async fn assemble_prompt(
        &self,
        session: &mut Session,
        config: &AgentLoopConfig,
    ) -> PromptAssemblyOutput {
        let base_prompt =
            crate::runtime::runner::session_setup::prompt_setup::resolve_base_prompt_for_language(
                config, session,
            );

        let tool_schemas =
            crate::runtime::runner::session_setup::tool_schemas::resolve_available_tool_schemas_for_session(
                config,
                self.tools.as_ref(),
                session,
            );

        let activated = activated_discoverable_tools(session);
        let tool_guide_context =
            crate::runtime::runner::session_setup::prompt_setup::build_tool_guide_context(
                config,
                &tool_schemas,
                base_prompt,
                &session.id,
                &activated,
            );

        let skill_context = session
            .metadata
            .get("skill.context")
            .cloned()
            .unwrap_or_default();

        let _report =
            crate::runtime::runner::session_setup::prompt_setup::apply_system_prompt_contexts(
                session,
                config,
                &skill_context,
                &tool_guide_context,
            );

        let effective_system_prompt = session
            .messages
            .iter()
            .find_map(|m| {
                if matches!(m.role, Role::System) {
                    Some(m.content.clone())
                } else {
                    None
                }
            })
            .unwrap_or_default();

        PromptAssemblyOutput {
            effective_system_prompt,
            skill_context,
            tool_guide_context,
        }
    }

    async fn refresh_external_memory(&self, session: &mut Session, config: &AgentLoopConfig) {
        crate::runtime::runner::prompt_context::inject_external_memory_into_system_message(
            session,
            config.prompt_memory_flags,
            None,
        )
        .await;
    }

    fn refresh_task_list(&self, session: &mut Session) {
        crate::runtime::runner::prompt_context::inject_task_list_into_system_message(session);
    }
}