unified-agent-api-claude-code 0.2.2

Async wrapper around the Claude Code CLI for non-interactive 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

use std::time::Duration;

mod support_paths;

use claude_code::{ClaudeClient, ClaudePrintRequest, ClaudeStreamJsonEvent};
use futures_util::StreamExt;

fn make_fake_client(scenario: &str) -> ClaudeClient {
    ClaudeClient::builder()
        .binary(support_paths::target_debug_binary(
            "fake_claude_stream_json",
        ))
        .env("FAKE_CLAUDE_SCENARIO", scenario)
        .build()
}

fn make_fake_client_mirroring_stdout(scenario: &str) -> ClaudeClient {
    ClaudeClient::builder()
        .binary(support_paths::target_debug_binary(
            "fake_claude_stream_json",
        ))
        .env("FAKE_CLAUDE_SCENARIO", scenario)
        .mirror_stdout(true)
        .build()
}

#[tokio::test]
async fn print_stream_json_yields_events_incrementally_before_process_exit() {
    let client = make_fake_client("two_events_delayed");
    let request = ClaudePrintRequest::new("hello");
    let handle = client.print_stream_json(request).await.unwrap();

    let mut events = handle.events;
    let mut completion = handle.completion;

    let first = tokio::select! {
        biased;
        res = &mut completion => panic!("completion resolved before first event: {res:?}"),
        item = events.next() => item.expect("stream open").expect("event parses"),
    };
    assert!(matches!(first, ClaudeStreamJsonEvent::SystemInit { .. }));

    let second = tokio::time::timeout(Duration::from_secs(1), events.next())
        .await
        .expect("expected second event")
        .expect("stream open")
        .expect("event parses");
    assert!(matches!(second, ClaudeStreamJsonEvent::UserMessage { .. }));

    completion.await.unwrap();
}

#[tokio::test(flavor = "current_thread")]
async fn print_stream_json_mirror_stdout_works_on_current_thread_runtime() {
    let client = make_fake_client_mirroring_stdout("two_events_delayed");
    let request = ClaudePrintRequest::new("hello");
    let handle = client.print_stream_json(request).await.unwrap();

    let mut events = handle.events;
    let mut completion = handle.completion;

    let first = tokio::select! {
        biased;
        res = &mut completion => panic!("completion resolved before first event: {res:?}"),
        item = tokio::time::timeout(Duration::from_secs(1), events.next()) => {
            item.expect("timeout waiting for first event")
                .expect("stream open")
                .expect("event parses")
        }
    };
    assert!(matches!(first, ClaudeStreamJsonEvent::SystemInit { .. }));

    let second = tokio::time::timeout(Duration::from_secs(1), events.next())
        .await
        .expect("expected second event")
        .expect("stream open")
        .expect("event parses");
    assert!(matches!(second, ClaudeStreamJsonEvent::UserMessage { .. }));

    completion.await.unwrap();
}

#[tokio::test]
async fn print_stream_json_ignores_crlf_and_blank_lines() {
    let client = make_fake_client("crlf_blank_lines");
    let request = ClaudePrintRequest::new("hello");
    let handle = client.print_stream_json(request).await.unwrap();

    let mut events = handle.events;
    let completion = handle.completion;

    let a = tokio::time::timeout(Duration::from_secs(1), events.next())
        .await
        .unwrap()
        .unwrap()
        .unwrap();
    let b = tokio::time::timeout(Duration::from_secs(1), events.next())
        .await
        .unwrap()
        .unwrap()
        .unwrap();
    assert!(matches!(a, ClaudeStreamJsonEvent::SystemInit { .. }));
    assert!(matches!(b, ClaudeStreamJsonEvent::UserMessage { .. }));

    assert!(events.next().await.is_none(), "no extra events expected");
    completion.await.unwrap();
}

#[tokio::test]
async fn print_stream_json_redacts_parse_errors() {
    let client = make_fake_client("parse_error_redaction");
    let request = ClaudePrintRequest::new("hello");
    let handle = client.print_stream_json(request).await.unwrap();

    let mut events = handle.events;
    let completion = handle.completion;

    let first = tokio::time::timeout(Duration::from_secs(1), events.next())
        .await
        .unwrap()
        .unwrap()
        .expect_err("expected parse error first");
    let secret = "VERY_SECRET_SHOULD_NOT_APPEAR";
    assert!(!first.message.contains(secret));
    assert!(!first.details.contains(secret));

    let second = tokio::time::timeout(Duration::from_secs(1), events.next())
        .await
        .unwrap()
        .unwrap()
        .unwrap();
    assert!(matches!(second, ClaudeStreamJsonEvent::SystemInit { .. }));

    assert!(events.next().await.is_none(), "no extra events expected");
    completion.await.unwrap();
}