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
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 actix_web::http::StatusCode;
use serde_json::json;
use std::collections::HashMap;

use bamboo_infrastructure::api::models::{
    ChatCompletionResponse, ChatMessage, Content, ResponseChoice, Role, Usage,
};
use bamboo_infrastructure::providers::anthropic::api_types::{
    AnthropicContent, AnthropicMessage, AnthropicMessagesRequest, AnthropicRole,
    AnthropicToolChoice,
};
use bamboo_infrastructure::providers::anthropic::conversion::AnthropicConversionError;

use super::conversion::{convert_messages_request, convert_messages_response};
use super::errors::map_conversion_error;

#[test]
fn convert_messages_request_should_convert_basic_user_text() {
    let request = AnthropicMessagesRequest {
        model: "claude-3-5-sonnet-latest".to_string(),
        messages: vec![AnthropicMessage {
            role: AnthropicRole::User,
            content: AnthropicContent::Text("hello".to_string()),
        }],
        system: None,
        max_tokens: Some(64),
        temperature: None,
        top_p: None,
        top_k: None,
        stop_sequences: None,
        stream: Some(false),
        tools: None,
        tool_choice: None,
        extra: HashMap::new(),
    };

    let converted = convert_messages_request(request).expect("request conversion should work");

    assert_eq!(converted.messages.len(), 1);
    assert_eq!(converted.parameters.get("max_tokens"), Some(&json!(64)));
    assert_eq!(
        converted.messages[0].content,
        Content::Text("hello".to_string())
    );
}

#[test]
fn convert_messages_response_should_map_tool_calls_to_tool_use_stop_reason() {
    let response = ChatCompletionResponse {
        id: "chatcmpl-1".to_string(),
        object: Some("chat.completion".to_string()),
        created: Some(1),
        model: Some("gpt-4o".to_string()),
        choices: vec![ResponseChoice {
            index: 0,
            message: ChatMessage {
                role: Role::Assistant,
                content: Content::Text("hi".to_string()),
                phase: None,
                tool_calls: None,
                tool_call_id: None,
            },
            finish_reason: Some("tool_calls".to_string()),
        }],
        usage: Some(Usage {
            prompt_tokens: 10,
            completion_tokens: 5,
            total_tokens: 15,
        }),
        system_fingerprint: None,
    };

    let converted = convert_messages_response(response, "claude-3-5-sonnet-latest")
        .expect("response conversion should work");

    assert_eq!(converted.stop_reason, "tool_use");
}

#[test]
fn convert_messages_request_should_preserve_provider_error_status_and_type() {
    let request = AnthropicMessagesRequest {
        model: "claude-3-5-sonnet-latest".to_string(),
        messages: vec![AnthropicMessage {
            role: AnthropicRole::User,
            content: AnthropicContent::Text("hello".to_string()),
        }],
        system: None,
        max_tokens: None,
        temperature: None,
        top_p: None,
        top_k: None,
        stop_sequences: None,
        stream: Some(false),
        tools: None,
        tool_choice: Some(AnthropicToolChoice::String("unsupported".to_string())),
        extra: HashMap::new(),
    };

    let error =
        convert_messages_request(request).expect_err("conversion should reject bad tool_choice");

    assert_eq!(error.status, StatusCode::BAD_REQUEST);
    assert_eq!(error.error_type, "invalid_request_error");
    assert!(error.message.contains("Unsupported tool_choice value"));
}

#[test]
fn map_conversion_error_should_fallback_to_bad_gateway_for_invalid_status_code() {
    let mapped = map_conversion_error(AnthropicConversionError::new(
        1000,
        "api_error",
        "invalid upstream status".to_string(),
    ));

    assert_eq!(mapped.status, StatusCode::BAD_GATEWAY);
}