kimi-wire 0.4.0

Typed Rust client for the Kimi Code CLI Wire protocol.
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

//! Tests for `kimi_wire::message::parse_wire_message`.

use kimi_wire::message::{parse_wire_message, WireMessage};
use kimi_wire::protocol::{
    ApprovalRequest, Event, JsonRpcError, JsonRpcVersion, RawWireMessage, Request,
};
use kimi_wire::WireError;

#[test]
fn test_parse_wire_message_request() {
    let raw = RawWireMessage {
        jsonrpc: JsonRpcVersion::V2,
        id: Some("req-1".to_string()),
        method: Some("request".to_string()),
        params: Some(
            serde_json::to_value(Request::ApprovalRequest(ApprovalRequest {
                id: "a1".to_string(),
                tool_call_id: "tc1".to_string(),
                sender: "test".to_string(),
                action: "act".to_string(),
                description: "desc".to_string(),
                display: None,
                source_kind: None,
                source_id: None,
                agent_id: None,
                subagent_type: None,
                source_description: None,
            }))
            .unwrap(),
        ),
        result: None,
        error: None,
    };
    let msg = parse_wire_message(raw).unwrap();
    assert!(matches!(msg, WireMessage::Request(_)));
}

#[test]
fn test_parse_wire_message_event() {
    let raw = RawWireMessage {
        jsonrpc: JsonRpcVersion::V2,
        id: None,
        method: Some("event".to_string()),
        params: Some(serde_json::to_value(Event::TurnEnd).unwrap()),
        result: None,
        error: None,
    };
    let msg = parse_wire_message(raw).unwrap();
    assert!(matches!(msg, WireMessage::Event(_)));
}

#[test]
fn test_parse_wire_message_success_response() {
    let raw = RawWireMessage {
        jsonrpc: JsonRpcVersion::V2,
        id: Some("resp-1".to_string()),
        method: None,
        params: None,
        result: Some(serde_json::json!({"status": "finished"})),
        error: None,
    };
    let msg = parse_wire_message(raw).unwrap();
    assert!(matches!(msg, WireMessage::SuccessResponse(_)));
}

#[test]
fn test_parse_wire_message_error_response() {
    let raw = RawWireMessage {
        jsonrpc: JsonRpcVersion::V2,
        id: Some("resp-2".to_string()),
        method: None,
        params: None,
        result: None,
        error: Some(JsonRpcError {
            code: -32601,
            message: "method not found".to_string(),
            data: None,
        }),
    };
    let msg = parse_wire_message(raw).unwrap();
    assert!(matches!(msg, WireMessage::ErrorResponse(_)));
}

#[test]
fn test_parse_wire_message_unknown_method() {
    let raw = RawWireMessage {
        jsonrpc: JsonRpcVersion::V2,
        id: Some("x".to_string()),
        method: Some("unknown_method".to_string()),
        params: Some(serde_json::json!({})),
        result: None,
        error: None,
    };
    let err = parse_wire_message(raw).unwrap_err();
    assert!(matches!(err, WireError::UnknownMessageType(m) if m == "unknown_method"));
}

#[test]
fn test_parse_wire_message_unrecognized_shape() {
    let raw = RawWireMessage {
        jsonrpc: JsonRpcVersion::V2,
        id: None,
        method: None,
        params: None,
        result: None,
        error: None,
    };
    let err = parse_wire_message(raw).unwrap_err();
    assert!(
        matches!(err, WireError::UnknownMessageType(m) if m == "unrecognized wire message shape")
    );
}