gproxy-protocol 2.9.10

GPROXY protocol types and endpoint metadata
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 serde::{Deserialize, Serialize};

use super::super::common::*;
use super::{ResponseCreateRequest, ResponseInput, ResponseStreamEvent};

pub type ResponseWebSocketWireModel =
    OpenAiWireModel<ResponseWebSocketRequest, ResponseStreamEvent>;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
#[allow(clippy::large_enum_variant)]
#[non_exhaustive]
pub enum ResponseWebSocketRequest {
    #[serde(rename = "response.create")]
    ResponseCreate(ResponseCreateWebSocketRequest),
    #[serde(rename = "response.steer")]
    ResponseSteer(ResponseSteerWebSocketRequest),
}

#[derive(
    Debug, Clone, PartialEq, Serialize, Deserialize, Default, gproxy_protocol_macros::WireBuilder,
)]
#[non_exhaustive]
pub struct ResponseCreateWebSocketRequest {
    #[serde(flatten)]
    pub response: ResponseCreateRequest,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub generate: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client_metadata: Option<Metadata>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
#[non_exhaustive]
pub struct ResponseSteerWebSocketRequest {
    pub previous_response_id: String,
    pub input: ResponseInput,
    #[serde(
        default,
        flatten,
        skip_serializing_if = "std::collections::BTreeMap::is_empty"
    )]
    pub extra: Extra,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
#[non_exhaustive]
pub struct ResponseSteerReference {
    pub id: String,
    pub previous_response_id: String,
    #[serde(
        default,
        flatten,
        skip_serializing_if = "std::collections::BTreeMap::is_empty"
    )]
    pub extra: Extra,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
#[non_exhaustive]
pub struct ResponseSteerFailure {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    pub previous_response_id: String,
    pub input: ResponseInput,
    #[serde(
        default,
        flatten,
        skip_serializing_if = "std::collections::BTreeMap::is_empty"
    )]
    pub extra: Extra,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
#[non_exhaustive]
pub struct ResponseSteerError {
    pub code: String,
    pub message: String,
    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
    pub type_: Option<String>,
    #[serde(
        default,
        flatten,
        skip_serializing_if = "std::collections::BTreeMap::is_empty"
    )]
    pub extra: Extra,
}

#[cfg(test)]
mod tests {
    use serde_json::json;

    use super::*;
    use crate::protocol::openai::{OpenAiModelId, ResponseInput};

    #[test]
    fn response_create_frame_round_trips_websocket_fields() {
        let value = json!({
            "type": "response.create",
            "model": "gpt-x",
            "input": "hello",
            "stream": true,
            "generate": false,
            "client_metadata": {
                "x-codex-installation-id": "installation-1"
            }
        });

        let parsed: ResponseWebSocketRequest = serde_json::from_value(value).unwrap();
        let ResponseWebSocketRequest::ResponseCreate(frame) = parsed else {
            panic!("expected response.create")
        };
        assert_eq!(
            frame.response.model,
            Some(OpenAiModelId::Unknown("gpt-x".to_owned()))
        );
        assert_eq!(
            frame.response.input,
            Some(ResponseInput::Text("hello".to_owned()))
        );
        assert_eq!(frame.response.stream, Some(true));
        assert_eq!(frame.generate, Some(false));
        assert_eq!(
            frame
                .client_metadata
                .as_ref()
                .and_then(|m| m.get("x-codex-installation-id")),
            Some(&"installation-1".to_owned())
        );

        let serialized = serde_json::to_value(ResponseWebSocketRequest::ResponseCreate(frame))
            .expect("serialize websocket response.create");
        assert_eq!(serialized["type"], json!("response.create"));
        assert_eq!(serialized["generate"], json!(false));
    }
}