va-ai-api-bridge 0.1.5

Protocol translation primitives for AI API request and response shapes.
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

use crate::{ContentBlock, EncodeState, UniversalEvent};

use super::*;

#[test]
fn message_start_uses_complete_anthropic_shape() {
    let events = encode(
        &[UniversalEvent::ResponseStart {
            id: Some("msg_1".to_string()),
            model: Some("qwen3-coder-next".to_string()),
            extensions: Default::default(),
        }],
        &mut EncodeState::default(),
    )
    .expect("events encode");

    let data = &events[0].data;
    assert_eq!(data["type"], "message_start");
    assert_eq!(data["message"]["type"], "message");
    assert_eq!(data["message"]["role"], "assistant");
    assert_eq!(data["message"]["content"], json!([]));
    assert_eq!(data["message"]["stop_reason"], Value::Null);
    assert_eq!(data["message"]["stop_sequence"], Value::Null);
    assert_eq!(
        data["message"]["usage"],
        json!({ "input_tokens": 0, "output_tokens": 0 })
    );
}

#[test]
fn message_delta_uses_object_usage_when_upstream_omits_usage() {
    let events = encode(
        &[
            UniversalEvent::ResponseStart {
                id: Some("msg_1".to_string()),
                model: Some("qwen3-coder-next".to_string()),
                extensions: Default::default(),
            },
            UniversalEvent::ContentStart {
                index: 0,
                block: ContentBlock::Text {
                    text: String::new(),
                },
            },
            UniversalEvent::TextDelta {
                index: 0,
                text: "OK".to_string(),
            },
            UniversalEvent::ContentDone {
                index: 0,
                final_block: None,
            },
            UniversalEvent::MessageDone {
                finish_reason: Some(crate::FinishReason::Stop),
                usage: None,
                extensions: Default::default(),
            },
            UniversalEvent::ResponseDone {
                usage: None,
                extensions: Default::default(),
            },
        ],
        &mut EncodeState::default(),
    )
    .expect("events encode");

    let message_delta = events
        .iter()
        .find(|event| event.data["type"] == "message_delta")
        .expect("message_delta");
    assert_eq!(message_delta.data["delta"]["stop_reason"], "end_turn");
    assert_eq!(message_delta.data["delta"]["stop_sequence"], Value::Null);
    assert_eq!(
        message_delta.data["usage"],
        json!({ "input_tokens": 0, "output_tokens": 0 })
    );
}

#[test]
fn response_done_closes_open_text_block_before_message_delta() {
    let events = encode(
        &[
            UniversalEvent::ResponseStart {
                id: Some("msg_1".to_string()),
                model: Some("qwen3-coder-next".to_string()),
                extensions: Default::default(),
            },
            UniversalEvent::ContentStart {
                index: 0,
                block: ContentBlock::Text {
                    text: String::new(),
                },
            },
            UniversalEvent::TextDelta {
                index: 0,
                text: "OK".to_string(),
            },
            UniversalEvent::MessageDone {
                finish_reason: Some(crate::FinishReason::Stop),
                usage: None,
                extensions: Default::default(),
            },
            UniversalEvent::ResponseDone {
                usage: None,
                extensions: Default::default(),
            },
        ],
        &mut EncodeState::default(),
    )
    .expect("events encode");

    let stop_index = events
        .iter()
        .position(|event| event.data["type"] == "content_block_stop")
        .expect("content_block_stop");
    let delta_index = events
        .iter()
        .position(|event| event.data["type"] == "message_delta")
        .expect("message_delta");

    assert!(stop_index < delta_index);
    assert_eq!(events[stop_index].data["index"], 0);
}