bamboo-server 2026.4.24

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
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 std::collections::HashMap;

use serde_json::Value;

use bamboo_domain::reasoning::ReasoningEffort;

pub(super) fn parse_reasoning_effort(
    parameters: &HashMap<String, Value>,
) -> Option<ReasoningEffort> {
    // OpenAI-style flat field: { "reasoning_effort": "medium" }
    if let Some(value) = parameters.get("reasoning_effort").and_then(|v| v.as_str()) {
        if let Some(effort) = ReasoningEffort::parse(value) {
            return Some(effort);
        }
    }

    // Responses-style object: { "reasoning": { "effort": "medium" } }
    if let Some(value) = parameters
        .get("reasoning")
        .and_then(|v| v.get("effort"))
        .and_then(|v| v.as_str())
    {
        if let Some(effort) = ReasoningEffort::parse(value) {
            return Some(effort);
        }
    }

    // Legacy/alternate: { "reasoning": "high" }
    if let Some(value) = parameters.get("reasoning").and_then(|v| v.as_str()) {
        if let Some(effort) = ReasoningEffort::parse(value) {
            return Some(effort);
        }
    }

    None
}

#[cfg(test)]
mod tests {
    use std::collections::HashMap;

    use serde_json::json;

    use super::parse_reasoning_effort;
    use bamboo_domain::reasoning::ReasoningEffort;

    fn params(value: serde_json::Value) -> HashMap<String, serde_json::Value> {
        serde_json::from_value(value).expect("valid parameters")
    }

    #[test]
    fn parses_flat_reasoning_effort_field() {
        let parameters = params(json!({
            "reasoning_effort": " HIGH "
        }));

        assert_eq!(
            parse_reasoning_effort(&parameters),
            Some(ReasoningEffort::High)
        );
    }

    #[test]
    fn parses_nested_responses_reasoning_effort() {
        let parameters = params(json!({
            "reasoning": {
                "effort": "medium"
            }
        }));

        assert_eq!(
            parse_reasoning_effort(&parameters),
            Some(ReasoningEffort::Medium)
        );
    }

    #[test]
    fn parses_legacy_reasoning_string() {
        let parameters = params(json!({
            "reasoning": "xhigh"
        }));

        assert_eq!(
            parse_reasoning_effort(&parameters),
            Some(ReasoningEffort::Xhigh)
        );
    }

    #[test]
    fn prefers_flat_reasoning_effort_over_other_formats() {
        let parameters = params(json!({
            "reasoning_effort": "low",
            "reasoning": {
                "effort": "high"
            }
        }));

        assert_eq!(
            parse_reasoning_effort(&parameters),
            Some(ReasoningEffort::Low)
        );
    }

    #[test]
    fn returns_none_for_invalid_reasoning_effort() {
        let invalid = params(json!({
            "reasoning_effort": "extreme"
        }));
        let missing = params(json!({
            "temperature": 0.2
        }));

        assert_eq!(parse_reasoning_effort(&invalid), None);
        assert_eq!(parse_reasoning_effort(&missing), None);
    }
}