gate4agent-handle 0.4.3

Bounded dispatch, snapshot, and event port for gate4agent
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

use gate4agent_handle::bounded_port;
use gate4agent_kernel::Gate4AgentKernel;
use gate4agent_types::{
    AgentId, AgentInstanceId, CommandEnvelope, CommandId, ControlCommand, ControlEffect,
    ProviderRuntimePolicy, SessionStatus, ApprovalLevel, StartRequest, TerminalSize, TransportKind,
};

#[test]
fn handle_drives_kernel_and_publishes_one_authoritative_snapshot() {
    let (handle, kernel_port) = bounded_port(8);
    let subscription = handle.subscribe(8);
    let instance_id = AgentInstanceId(41);
    handle
        .dispatch(CommandEnvelope {
            id: CommandId(1),
            command: ControlCommand::Register {
                instance_id,
                agent_id: AgentId::new("claude").unwrap(),
                transport: TransportKind::Pty,
            },
        })
        .unwrap();
    handle
        .dispatch(CommandEnvelope {
            id: CommandId(2),
            command: ControlCommand::Start {
                instance_id,
                runtime_policy: ProviderRuntimePolicy::new(true, true, true, true, true, false)
                    .unwrap(),
                request: StartRequest {
                    working_directory: ".".to_owned(),
                    terminal_size: TerminalSize {
                        rows: 24,
                        columns: 80,
                    },
                    initial_prompt: None,
                    session_options: None,
                    approval_level: ApprovalLevel::default(),
                },
            },
        })
        .unwrap();

    let mut kernel = Gate4AgentKernel::default();
    let step = kernel.step(kernel_port.drain_commands(8), []);
    kernel_port.publish_snapshot(step.snapshot.clone());
    let report = kernel_port.publish_events(step.events.clone());

    assert!(step.command_outcomes.iter().all(|outcome| outcome.result.is_ok()));
    assert!(matches!(step.effects[0].effect, ControlEffect::Spawn { .. }));
    assert_eq!(handle.snapshot().sessions[0].status, SessionStatus::Starting);
    assert_eq!(report.delivered, 2);
    assert_eq!(subscription.try_recv().unwrap().sequence, 1);
    assert_eq!(subscription.try_recv().unwrap().sequence, 2);
}