gproxy-protocol 4.1.4

GPROXY v4 connection modelling, operation declarations, vendor wire types and pairwise conversion
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

use crate::{
    transform::{Report, TransformError},
    wire::openai::{chat::response as c, responses::response as r},
};

pub(crate) fn to_responses(
    value: c::ModerationResponse,
    report: &mut Report,
) -> Result<r::ResponseModerationReport, TransformError> {
    Ok(r::ResponseModerationReport {
        input: outcome_to_responses(value.input, report)?,
        output: outcome_to_responses(value.output, report)?,
        rest: Default::default(),
    })
}

fn outcome_to_responses(
    value: c::ModerationResultOrError,
    report: &mut Report,
) -> Result<r::ResponseModerationOutcome, TransformError> {
    Ok(match value {
        c::ModerationResultOrError::Error(value) => {
            r::ResponseModerationOutcome::Error(r::ResponseModerationError {
                code: value.code,
                message: value.message,
                type_: r::ResponseModerationErrorType::Error,
                rest: Default::default(),
            })
        }
        c::ModerationResultOrError::Result(value) => {
            if value.results.len() != 1 {
                return Err(TransformError::unsupported(
                    "moderation.results",
                    "Responses has one moderation result per input/output, not a batch",
                ));
            }
            let item = value.results.into_iter().next().expect("one result");
            if value.model != item.model {
                report.omitted(
                    "moderation.model",
                    "Responses retains per-result model; Chat batch model differs",
                );
            }
            r::ResponseModerationOutcome::Result(r::ResponseModerationResult {
                categories: item.categories,
                category_applied_input_types: item
                    .category_applied_input_types
                    .into_iter()
                    .map(|(k, v)| {
                        (
                            k,
                            v.into_iter()
                                .map(|v| match v {
                                    c::ModerationInputType::Text => {
                                        r::ResponseModerationInputType::Text
                                    }
                                    c::ModerationInputType::Image => {
                                        r::ResponseModerationInputType::Image
                                    }
                                })
                                .collect(),
                        )
                    })
                    .collect(),
                category_scores: item
                    .category_scores
                    .into_iter()
                    .map(|(k, v)| {
                        Ok((
                            k,
                            serde_json::Number::from_f64(v).ok_or_else(|| {
                                TransformError::invalid_result(
                                    "moderation.category_scores",
                                    "non-finite score",
                                )
                            })?,
                        ))
                    })
                    .collect::<Result<_, TransformError>>()?,
                flagged: item.flagged,
                model: item.model,
                type_: r::ResponseModerationResultType::ModerationResult,
                rest: Default::default(),
            })
        }
    })
}

pub(crate) fn to_chat(
    value: r::ResponseModerationReport,
) -> Result<c::ModerationResponse, TransformError> {
    Ok(c::ModerationResponse {
        input: outcome_to_chat(value.input)?,
        output: outcome_to_chat(value.output)?,
        rest: Default::default(),
    })
}

fn outcome_to_chat(
    value: r::ResponseModerationOutcome,
) -> Result<c::ModerationResultOrError, TransformError> {
    Ok(match value {
        r::ResponseModerationOutcome::Error(value) => {
            c::ModerationResultOrError::Error(c::ModerationError {
                code: value.code,
                message: value.message,
                type_: c::ModerationErrorType::Error,
                rest: Default::default(),
            })
        }
        r::ResponseModerationOutcome::Result(value) => {
            c::ModerationResultOrError::Result(c::ModerationResult {
                model: value.model.clone(),
                type_: c::ModerationResultType::ModerationResults,
                results: vec![c::ModerationResultItem {
                    categories: value.categories,
                    category_applied_input_types: value
                        .category_applied_input_types
                        .into_iter()
                        .map(|(k, v)| {
                            (
                                k,
                                v.into_iter()
                                    .map(|v| match v {
                                        r::ResponseModerationInputType::Text => {
                                            c::ModerationInputType::Text
                                        }
                                        r::ResponseModerationInputType::Image => {
                                            c::ModerationInputType::Image
                                        }
                                    })
                                    .collect(),
                            )
                        })
                        .collect(),
                    category_scores: value
                        .category_scores
                        .into_iter()
                        .map(|(k, v)| {
                            Ok((
                                k,
                                v.as_f64().filter(|n| n.is_finite()).ok_or_else(|| {
                                    TransformError::invalid_result(
                                        "moderation.category_scores",
                                        "score exceeds target numeric range",
                                    )
                                })?,
                            ))
                        })
                        .collect::<Result<_, TransformError>>()?,
                    flagged: value.flagged,
                    model: value.model,
                    type_: c::ModerationItemType::ModerationResult,
                    rest: Default::default(),
                }],
                rest: Default::default(),
            })
        }
    })
}