va-ai-api-bridge 0.1.7

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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

mod state;

use serde_json::{json, Value};

use crate::translator::{anthropic, common};
use crate::{EncodeState, Result, UniversalEvent, WireEvent};

use self::state::*;

pub(super) fn encode(events: &[UniversalEvent], state: &mut EncodeState) -> Result<Vec<WireEvent>> {
    let mut wire_events = Vec::new();
    for event in events {
        match event {
            UniversalEvent::ResponseStart { id, model, .. } => {
                wire_events.push(common::wire_event(json!({
                    "type": "message_start",
                    "message": {
                        "id": id,
                        "type": "message",
                        "model": model,
                        "role": "assistant",
                        "content": [],
                        "stop_reason": Value::Null,
                        "stop_sequence": Value::Null,
                        "usage": {
                            "input_tokens": 0,
                            "output_tokens": 0
                        }
                    }
                })))
            }
            UniversalEvent::ContentStart { index, block } => {
                close_open_content_blocks_before_start(state, &mut wire_events, *index);
                reserve_index(state, *index);
                remember_content_started(state, *index);
                match block {
                    crate::ContentBlock::ToolCall { id, name, .. } => {
                        remember_tool_id(state, id);
                        remember_tool_index(state, id, *index);
                        state
                            .extensions
                            .insert(tool_name_key(id), Value::String(name.clone()));
                        state
                            .extensions
                            .insert(tool_started_key(id), Value::Bool(true));
                        wire_events.push(common::wire_event(json!({
                            "type": "content_block_start",
                            "index": index,
                            "content_block": {
                                "type": "tool_use",
                                "id": id,
                                "name": name,
                                "input": {}
                            }
                        })));
                    }
                    _ => wire_events.push(common::wire_event(json!({
                        "type": "content_block_start",
                        "index": index,
                        "content_block": anthropic::block_to_anthropic_block(block)
                    }))),
                }
            }
            UniversalEvent::TextDelta { index, text } => {
                wire_events.push(common::wire_event(json!({
                    "type": "content_block_delta",
                    "index": index,
                    "delta": {
                        "type": "text_delta",
                        "text": text
                    }
                })))
            }
            UniversalEvent::ReasoningDelta { index, text } => {
                wire_events.push(common::wire_event(json!({
                    "type": "content_block_delta",
                    "index": index,
                    "delta": {
                        "type": "thinking_delta",
                        "thinking": text
                    }
                })))
            }
            UniversalEvent::ToolCallDelta {
                id,
                name,
                arguments_delta,
                ..
            } => {
                let index = ensure_tool_block_started(state, &mut wire_events, id, name.as_deref());
                if !arguments_delta.is_empty() {
                    wire_events.push(common::wire_event(json!({
                        "type": "content_block_delta",
                        "index": index,
                        "delta": {
                            "type": "input_json_delta",
                            "partial_json": arguments_delta
                        }
                    })));
                }
            }
            UniversalEvent::ContentDone { index, .. } => {
                remember_content_closed(state, *index);
                if let Some(id) = tool_id_for_index(state, *index) {
                    state
                        .extensions
                        .insert(tool_closed_key(&id), Value::Bool(true));
                }
                wire_events.push(common::wire_event(json!({
                    "type": "content_block_stop",
                    "index": index
                })));
            }
            UniversalEvent::MessageDone {
                finish_reason,
                usage,
                ..
            } => {
                remember_message_done(state, *finish_reason, usage);
            }
            UniversalEvent::ResponseDone { usage, .. } => {
                close_open_content_blocks(state, &mut wire_events);
                close_open_tool_blocks(state, &mut wire_events);
                if !message_delta_sent(state) {
                    let usage = response_usage(usage, state);
                    wire_events.push(common::wire_event(json!({
                        "type": "message_delta",
                        "delta": {
                            "stop_reason": finish_to_anthropic(normalize_finish_reason(
                                pending_finish_reason(state),
                                state,
                            )),
                            "stop_sequence": Value::Null
                        },
                        "usage": usage
                    })));
                    state
                        .extensions
                        .insert("anthropicMessageDeltaSent".to_string(), Value::Bool(true));
                }
                wire_events.push(common::wire_event(json!({
                "type": "message_stop"
                })));
            }
            UniversalEvent::Error { message, raw } => wire_events.push(common::wire_event(json!({
                "type": "error",
                "error": {
                    "message": message,
                    "raw": raw
                }
            }))),
            UniversalEvent::Unknown { raw, .. } => {
                wire_events.push(common::wire_event(raw.clone()))
            }
            UniversalEvent::MessageStart { .. } => {}
        }
    }
    Ok(wire_events)
}

#[cfg(test)]
mod tests;