codeswarm-adapters 0.10.13

Reusable ACP and native coding-agent adapters for CodeSwarm
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

use std::time::Duration;

use codeswarm_adapters::{AgentAdapter, AgentEvent, CodexAdapter};

async fn drain_startup(adapter: &mut CodexAdapter) {
    loop {
        let event = adapter
            .next_event()
            .await
            .expect("startup event")
            .expect("startup");
        eprintln!("STARTUP {event:?}");
        if matches!(event, AgentEvent::Ready { .. }) {
            break;
        }
    }
}

async fn run_prompt(adapter: &mut CodexAdapter, prompt: &str) -> Vec<AgentEvent> {
    adapter
        .send_prompt(prompt.to_owned())
        .await
        .expect("send prompt");
    let mut events = Vec::new();
    loop {
        let event = tokio::time::timeout(Duration::from_secs(120), adapter.next_event())
            .await
            .expect("Codex event timeout")
            .expect("Codex stream ended")
            .expect("Codex adapter error");
        eprintln!("EVENT {event:?}");
        let terminal = matches!(
            event,
            AgentEvent::TurnComplete { .. } | AgentEvent::Failed { .. }
        );
        events.push(event);
        if terminal {
            return events;
        }
    }
}

#[tokio::test]
#[ignore = "uses the installed authenticated Codex CLI"]
async fn real_codex_adapter_trace() {
    let mut adapter = CodexAdapter::new(0, std::env::current_dir().unwrap(), "codex");
    adapter.start().await.expect("start adapter");
    drain_startup(&mut adapter).await;

    let greeting = run_prompt(
        &mut adapter,
        "Respond exactly READY. Do not call any tools.",
    )
    .await;
    assert!(
        !greeting
            .iter()
            .any(|event| matches!(event, AgentEvent::Tool { .. })),
        "a no-tool response produced a tool event"
    );
    assert!(matches!(
        greeting.last(),
        Some(AgentEvent::TurnComplete { .. })
    ));
    assert!(
        !greeting
            .iter()
            .any(|event| matches!(event, AgentEvent::Failed { .. }))
    );
    assert!(greeting.iter().any(|event| matches!(
        event,
        AgentEvent::Text { text, .. } if text == "READY"
    )));

    let command = run_prompt(
        &mut adapter,
        "Reason briefly about the current directory, use the shell tool to run pwd, then respond exactly DONE.",
    )
    .await;
    assert!(command.iter().any(|event| matches!(
        event,
        AgentEvent::Tool { update, .. }
            if update.title.contains("pwd")
                && update.status == codeswarm_adapters::ToolStatus::Running
                && update.detail.is_none()
    )));
    assert!(command.iter().any(|event| matches!(
        event,
        AgentEvent::Tool { update, .. }
            if update.title.contains("pwd")
                && update.status == codeswarm_adapters::ToolStatus::Completed
    )));
    assert!(matches!(
        command.last(),
        Some(AgentEvent::TurnComplete { .. })
    ));
    assert!(
        !command
            .iter()
            .any(|event| matches!(event, AgentEvent::Failed { .. }))
    );
    assert!(command.iter().any(|event| matches!(
        event,
        AgentEvent::Text { text, .. } if text == "DONE"
    )));
    adapter.stop().await.expect("stop adapter");
}