bamboo-domain 2026.10.21

Domain models and shared types 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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! The unpublished remote contract is intentionally narrower than self control.
//! These are stateless wire checks, not runtime/host authority grants.
use super::*;

fn binding() -> ScopedLoopControlBinding {
    ScopedLoopControlBinding {
        grant_id: Uuid::from_u128(1),
        supervisor: SupervisorReference {
            session_id: DEFAULT_SUPERVISOR_SESSION_ID.into(),
            incarnation_id: Uuid::from_u128(2),
        },
        supervisor_tool_authority_revision: 0,
        target_session_id: "remote-objective-target".into(),
        target_created_at: Utc::now(),
        target_metadata_version: 0,
        target_project_id: "remote-objective-project".parse().unwrap(),
        link_revision: 1,
        owner_run_id: "remote-objective-owner".into(),
        execution_id: "remote-objective-execution".into(),
        allowed_actions: [
            LoopControlAction::Status,
            LoopControlAction::Start,
            LoopControlAction::Update,
            LoopControlAction::Stop,
        ]
        .into_iter()
        .collect(),
        max_iterations: 3,
        max_total_rounds: 12,
    }
}

fn start(objective: &str) -> LoopControlRequest {
    LoopControlRequest::Start {
        operation_id: Uuid::from_u128(3).to_string(),
        expected_generation: None,
        expected_revision: 0,
        objective: objective.into(),
        max_iterations: 3,
        max_total_rounds: 12,
    }
}

fn update(objective: Option<String>) -> LoopControlRequest {
    LoopControlRequest::Update {
        operation_id: Uuid::from_u128(4).to_string(),
        generation: Uuid::from_u128(5).to_string(),
        expected_revision: 0,
        objective,
        max_iterations: None,
        max_total_rounds: Some(10),
    }
}

#[test]
fn scoped_objective_scalar_limit_explicitly_preserves_the_self_byte_contract() {
    let binding = binding();
    binding.validate().unwrap();
    for (label, objective, self_valid, remote_valid) in [
        ("ASCII 4096", "x".repeat(4096), true, true),
        ("CJK 4096", "ē•Œ".repeat(4096), true, true),
        ("emoji 4096 exact 16 KiB", "šŸ˜€".repeat(4096), true, true),
        ("mixed 4096", "aĆ©ē•ŒšŸ˜€".repeat(1024), true, true),
        ("FEFF is content", "\u{feff}".repeat(4096), true, true),
        (
            "NEL around content",
            format!("{}x", "\u{0085}".repeat(4095)),
            true,
            true,
        ),
        (
            "raw spaces count",
            format!("{}x", " ".repeat(4096)),
            true,
            false,
        ),
        ("ASCII 4097", "x".repeat(4097), true, false),
        ("old candidate ASCII 16 KiB", "x".repeat(16384), true, false),
        ("old candidate CJK 5000", "ē•Œ".repeat(5000), true, false),
        (
            "old candidate mixed exact 16 KiB",
            format!("{}abcd", "aĆ©ē•ŒšŸ˜€".repeat(1638)),
            true,
            false,
        ),
        ("reported CJK 5500", "ē•Œ".repeat(5500), false, false),
        ("emoji 4097", "šŸ˜€".repeat(4097), false, false),
        ("NEL only", "\u{0085}".repeat(4096), false, false),
    ] {
        for command in [start(&objective), update(Some(objective.clone()))] {
            let before = serde_json::to_value(&command).unwrap();
            assert_eq!(command.validate().is_ok(), self_valid, "{label}: self DTO");
            assert_eq!(
                binding.authorize(&command).is_ok(),
                remote_valid,
                "{label}/{}: remote contract",
                command.action()
            );
            assert_eq!(
                serde_json::to_value(command).unwrap(),
                before,
                "validation must not trim, normalize or rewrite objective text"
            );
        }
    }
    let bound_only = update(None);
    let value = serde_json::to_value(&bound_only).unwrap();
    assert!(value["objective"].is_null());
    binding.authorize(&bound_only).unwrap();
    binding.authorize(&LoopControlRequest::Status).unwrap();
}

#[test]
fn typed_remote_carrier_cannot_bypass_the_scalar_limit() {
    let input = ScopedLoopControlInput {
        binding: binding(),
        command: start("seed"),
    };
    let envelope = input.envelope().unwrap();
    for (objective, valid) in [
        ("šŸ˜€".repeat(4096), true),
        ("x".repeat(4097), false),
        ("ē•Œ".repeat(5000), false),
    ] {
        // The stable operation/input identity does not hash objective text.
        // Mutating only typed data isolates carrier parsing from Tool/Messenger.
        let mut carrier = envelope.clone();
        let SessionMessageBody::RuntimeInstruction(instruction) = &mut carrier.body else {
            unreachable!()
        };
        instruction.data.as_mut().unwrap()["command"]["objective"] = serde_json::json!(&objective);
        let parsed = scoped_loop_control_input(&carrier);
        assert_eq!(
            parsed.is_ok(),
            valid,
            "{} scalars",
            objective.chars().count()
        );
        if valid {
            let parsed = parsed.unwrap().unwrap();
            assert_eq!(parsed.command, start(&objective));
            assert_eq!(parsed.envelope().unwrap().id, envelope.id);
        }
    }
}