acp-cli 0.3.1

Headless CLI client for the Agent Client Protocol (ACP)
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::io::{self, Write};

use serde_json::json;

use super::OutputRenderer;

pub struct JsonRenderer {
    suppress_reads: bool,
}

impl JsonRenderer {
    pub fn new(suppress_reads: bool) -> Self {
        Self { suppress_reads }
    }

    fn emit(&self, value: serde_json::Value) {
        let line = serde_json::to_string(&value).expect("failed to serialize JSON output");
        println!("{line}");
        let _ = io::stdout().flush();
    }
}

impl OutputRenderer for JsonRenderer {
    fn text_chunk(&mut self, text: &str) {
        self.emit(json!({"type": "text", "content": text}));
    }

    fn tool_status(&mut self, tool: &str) {
        self.emit(json!({"type": "tool", "name": tool}));
    }

    fn tool_result(&mut self, tool: &str, output: &str, is_read: bool) {
        self.emit(build_tool_result_event(
            tool,
            output,
            self.suppress_reads,
            is_read,
        ));
    }

    fn permission_denied(&mut self, tool: &str) {
        self.emit(json!({"type": "error", "message": format!("permission denied: {tool}")}));
    }

    fn error(&mut self, err: &str) {
        self.emit(json!({"type": "error", "message": err}));
    }

    fn session_info(&mut self, id: &str) {
        self.emit(json!({"type": "session", "sessionId": id}));
    }

    fn done(&mut self) {
        self.emit(json!({"type": "done"}));
    }
}

/// Build the JSON value for a `tool_result` event. Extracted for testability.
fn build_tool_result_event(
    tool: &str,
    output: &str,
    suppress_reads: bool,
    is_read: bool,
) -> serde_json::Value {
    if suppress_reads && is_read {
        json!({
            "type": "tool_result",
            "name": tool,
            "output": "[suppressed]",
            "suppressed": true,
        })
    } else {
        json!({
            "type": "tool_result",
            "name": tool,
            "output": output,
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn tool_result_suppressed_when_suppress_reads_and_is_read() {
        let v = build_tool_result_event("Read File", "file contents", true, true);
        assert_eq!(v["type"], "tool_result");
        assert_eq!(v["name"], "Read File");
        assert_eq!(v["output"], "[suppressed]");
        assert_eq!(v["suppressed"], true);
    }

    #[test]
    fn tool_result_not_suppressed_when_is_read_false() {
        let v = build_tool_result_event("Bash", "output text", true, false);
        assert_eq!(v["output"], "output text");
        assert!(v.get("suppressed").is_none());
    }

    #[test]
    fn tool_result_not_suppressed_when_suppress_reads_false() {
        let v = build_tool_result_event("Read File", "file contents", false, true);
        assert_eq!(v["output"], "file contents");
        assert!(v.get("suppressed").is_none());
    }
}