unified-agent-api-codex 0.2.2

Async wrapper around the Codex CLI for programmatic prompting
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

use codex::{
    EventError, ItemDelta, ItemDeltaPayload, ItemEnvelope, ItemFailure, ItemPayload, ItemSnapshot,
    ItemStatus, TextContent, TextDelta, ThreadEvent, ThreadStarted, TurnCompleted, TurnFailed,
    TurnStarted,
};
use std::collections::BTreeMap;

fn stored_thread_id(event: &ThreadEvent) -> &String {
    match event {
        ThreadEvent::ThreadStarted(inner) => &inner.thread_id,
        ThreadEvent::TurnStarted(inner) => &inner.thread_id,
        ThreadEvent::TurnCompleted(inner) => &inner.thread_id,
        ThreadEvent::TurnFailed(inner) => &inner.thread_id,
        ThreadEvent::ItemStarted(inner) => &inner.thread_id,
        ThreadEvent::ItemDelta(inner) => &inner.thread_id,
        ThreadEvent::ItemCompleted(inner) => &inner.thread_id,
        ThreadEvent::ItemFailed(inner) => &inner.thread_id,
        ThreadEvent::Error(_) => panic!("ThreadEvent::Error has no thread id"),
    }
}

fn assert_thread_id_borrowed(event: &ThreadEvent, expected: &str) {
    let id = event
        .thread_id()
        .expect("expected thread_id() to return Some");
    assert_eq!(id, expected);

    let stored = stored_thread_id(event);
    assert_eq!(id.as_ptr(), stored.as_ptr());
    assert_eq!(id.len(), stored.len());
}

#[test]
fn thread_id_accessor_is_pinned_and_borrowed() {
    let expected = "thread-123";

    let events = vec![
        ThreadEvent::ThreadStarted(ThreadStarted {
            thread_id: expected.to_string(),
            extra: BTreeMap::new(),
        }),
        ThreadEvent::TurnStarted(TurnStarted {
            thread_id: expected.to_string(),
            turn_id: "turn-1".to_string(),
            input_text: None,
            extra: BTreeMap::new(),
        }),
        ThreadEvent::TurnCompleted(TurnCompleted {
            thread_id: expected.to_string(),
            turn_id: "turn-1".to_string(),
            last_item_id: None,
            extra: BTreeMap::new(),
        }),
        ThreadEvent::TurnFailed(TurnFailed {
            thread_id: expected.to_string(),
            turn_id: "turn-1".to_string(),
            error: EventError {
                message: "fail".to_string(),
                code: None,
                extra: BTreeMap::new(),
            },
            extra: BTreeMap::new(),
        }),
        ThreadEvent::ItemStarted(ItemEnvelope {
            thread_id: expected.to_string(),
            turn_id: "turn-1".to_string(),
            item: ItemSnapshot {
                item_id: "item-1".to_string(),
                index: None,
                status: ItemStatus::InProgress,
                payload: ItemPayload::AgentMessage(TextContent {
                    text: "".to_string(),
                    extra: BTreeMap::new(),
                }),
                extra: BTreeMap::new(),
            },
        }),
        ThreadEvent::ItemDelta(ItemDelta {
            thread_id: expected.to_string(),
            turn_id: "turn-1".to_string(),
            item_id: "item-1".to_string(),
            index: None,
            delta: ItemDeltaPayload::AgentMessage(TextDelta {
                text_delta: "".to_string(),
                extra: BTreeMap::new(),
            }),
            extra: BTreeMap::new(),
        }),
        ThreadEvent::ItemCompleted(ItemEnvelope {
            thread_id: expected.to_string(),
            turn_id: "turn-1".to_string(),
            item: ItemSnapshot {
                item_id: "item-1".to_string(),
                index: None,
                status: ItemStatus::Completed,
                payload: ItemPayload::AgentMessage(TextContent {
                    text: "".to_string(),
                    extra: BTreeMap::new(),
                }),
                extra: BTreeMap::new(),
            },
        }),
        ThreadEvent::ItemFailed(ItemEnvelope {
            thread_id: expected.to_string(),
            turn_id: "turn-1".to_string(),
            item: ItemFailure {
                item_id: "item-1".to_string(),
                index: None,
                error: EventError {
                    message: "fail".to_string(),
                    code: None,
                    extra: BTreeMap::new(),
                },
                extra: BTreeMap::new(),
            },
        }),
    ];

    for event in &events {
        assert_thread_id_borrowed(event, expected);
    }
}

#[test]
fn error_event_has_no_thread_id() {
    let event = ThreadEvent::Error(EventError {
        message: "boom".to_string(),
        code: None,
        extra: BTreeMap::new(),
    });

    assert!(event.thread_id().is_none());
}

#[test]
fn accessor_does_not_normalize_thread_id() {
    let raw = "  thread-123  ";
    let event = ThreadEvent::ThreadStarted(ThreadStarted {
        thread_id: raw.to_string(),
        extra: BTreeMap::new(),
    });

    assert_thread_id_borrowed(&event, raw);
}